//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS IoTWireless service.
///
/// AWS IoT Wireless provides bi-directional communication between internet-connected wireless devices and the AWS Cloud. To onboard both LoRaWAN and Sidewalk devices to AWS IoT, use the IoT Wireless API. These wireless devices use the Low Power Wide Area Networking (LPWAN) communication protocol to communicate with AWS IoT.  Using the API, you can perform create, read, update, and delete operations for your wireless devices, gateways, destinations, and profiles. After onboarding your devices, you can use the API operations to set log levels and monitor your devices with CloudWatch. You can also use the API operations to create multicast groups and schedule a multicast session for sending a downlink message to devices in the group. By using Firmware Updates Over-The-Air (FUOTA) API operations, you can create a FUOTA task and schedule a session to update the firmware of individual devices or an entire group of devices in a multicast group. To connect to the AWS IoT Wireless Service, use the Service endpoints as described in IoT  Wireless Service endpoints. You can use both IPv4 and IPv6 protocols to connect to the endpoints and send requests to the AWS IoT Wireless service. For more information, see Using
/// 			IPv6 with AWS IoT Wireless.
public struct IoTWireless: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the IoTWireless client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "IoTWireless",
            serviceIdentifier: "api.iotwireless",
            signingName: "iotwireless",
            serviceProtocol: .restjson,
            apiVersion: "2020-11-22",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            errorType: IoTWirelessErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "ap-northeast-1": "api.iotwireless.ap-northeast-1.amazonaws.com",
        "ap-southeast-2": "api.iotwireless.ap-southeast-2.amazonaws.com",
        "eu-central-1": "api.iotwireless.eu-central-1.amazonaws.com",
        "eu-west-1": "api.iotwireless.eu-west-1.amazonaws.com",
        "sa-east-1": "api.iotwireless.sa-east-1.amazonaws.com",
        "us-east-1": "api.iotwireless.us-east-1.amazonaws.com",
        "us-west-2": "api.iotwireless.us-west-2.amazonaws.com"
    ]}



    // MARK: API Calls

    /// Associates a partner account with your AWS account.
    @Sendable
    @inlinable
    public func associateAwsAccountWithPartnerAccount(_ input: AssociateAwsAccountWithPartnerAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateAwsAccountWithPartnerAccountResponse {
        try await self.client.execute(
            operation: "AssociateAwsAccountWithPartnerAccount", 
            path: "/partner-accounts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a partner account with your AWS account.
    ///
    /// Parameters:
    ///   - clientRequestToken: Each resource must have a unique client request token. The client token is used to implement idempotency. It ensures that the request completes no more than one time. If you retry a request with the same token and the same parameters, the request will complete successfully. However, if you try to create a new resource using the same token but different parameters, an HTTP 409 conflict occurs. If you omit this value, AWS SDKs will automatically generate a unique client request. For more information about idempotency, see Ensuring idempotency in Amazon EC2 API requests.
    ///   - sidewalk: The Sidewalk account credentials.
    ///   - tags: The tags to attach to the specified resource. Tags are metadata that you can use to manage a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateAwsAccountWithPartnerAccount(
        clientRequestToken: String? = AssociateAwsAccountWithPartnerAccountRequest.idempotencyToken(),
        sidewalk: SidewalkAccountInfo,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateAwsAccountWithPartnerAccountResponse {
        let input = AssociateAwsAccountWithPartnerAccountRequest(
            clientRequestToken: clientRequestToken, 
            sidewalk: sidewalk, 
            tags: tags
        )
        return try await self.associateAwsAccountWithPartnerAccount(input, logger: logger)
    }

    /// Associate a multicast group with a FUOTA task.
    @Sendable
    @inlinable
    public func associateMulticastGroupWithFuotaTask(_ input: AssociateMulticastGroupWithFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateMulticastGroupWithFuotaTaskResponse {
        try await self.client.execute(
            operation: "AssociateMulticastGroupWithFuotaTask", 
            path: "/fuota-tasks/{Id}/multicast-group", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associate a multicast group with a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - multicastGroupId: 
    ///   - logger: Logger use during operation
    @inlinable
    public func associateMulticastGroupWithFuotaTask(
        id: String,
        multicastGroupId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateMulticastGroupWithFuotaTaskResponse {
        let input = AssociateMulticastGroupWithFuotaTaskRequest(
            id: id, 
            multicastGroupId: multicastGroupId
        )
        return try await self.associateMulticastGroupWithFuotaTask(input, logger: logger)
    }

    /// Associate a wireless device with a FUOTA task.
    @Sendable
    @inlinable
    public func associateWirelessDeviceWithFuotaTask(_ input: AssociateWirelessDeviceWithFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateWirelessDeviceWithFuotaTaskResponse {
        try await self.client.execute(
            operation: "AssociateWirelessDeviceWithFuotaTask", 
            path: "/fuota-tasks/{Id}/wireless-device", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associate a wireless device with a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - wirelessDeviceId: 
    ///   - logger: Logger use during operation
    @inlinable
    public func associateWirelessDeviceWithFuotaTask(
        id: String,
        wirelessDeviceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateWirelessDeviceWithFuotaTaskResponse {
        let input = AssociateWirelessDeviceWithFuotaTaskRequest(
            id: id, 
            wirelessDeviceId: wirelessDeviceId
        )
        return try await self.associateWirelessDeviceWithFuotaTask(input, logger: logger)
    }

    /// Associates a wireless device with a multicast group.
    @Sendable
    @inlinable
    public func associateWirelessDeviceWithMulticastGroup(_ input: AssociateWirelessDeviceWithMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateWirelessDeviceWithMulticastGroupResponse {
        try await self.client.execute(
            operation: "AssociateWirelessDeviceWithMulticastGroup", 
            path: "/multicast-groups/{Id}/wireless-device", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a wireless device with a multicast group.
    ///
    /// Parameters:
    ///   - id: 
    ///   - wirelessDeviceId: 
    ///   - logger: Logger use during operation
    @inlinable
    public func associateWirelessDeviceWithMulticastGroup(
        id: String,
        wirelessDeviceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateWirelessDeviceWithMulticastGroupResponse {
        let input = AssociateWirelessDeviceWithMulticastGroupRequest(
            id: id, 
            wirelessDeviceId: wirelessDeviceId
        )
        return try await self.associateWirelessDeviceWithMulticastGroup(input, logger: logger)
    }

    /// Associates a wireless device with a thing.
    @Sendable
    @inlinable
    public func associateWirelessDeviceWithThing(_ input: AssociateWirelessDeviceWithThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateWirelessDeviceWithThingResponse {
        try await self.client.execute(
            operation: "AssociateWirelessDeviceWithThing", 
            path: "/wireless-devices/{Id}/thing", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a wireless device with a thing.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to update.
    ///   - thingArn: The ARN of the thing to associate with the wireless device.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateWirelessDeviceWithThing(
        id: String,
        thingArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateWirelessDeviceWithThingResponse {
        let input = AssociateWirelessDeviceWithThingRequest(
            id: id, 
            thingArn: thingArn
        )
        return try await self.associateWirelessDeviceWithThing(input, logger: logger)
    }

    /// Associates a wireless gateway with a certificate.
    @Sendable
    @inlinable
    public func associateWirelessGatewayWithCertificate(_ input: AssociateWirelessGatewayWithCertificateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateWirelessGatewayWithCertificateResponse {
        try await self.client.execute(
            operation: "AssociateWirelessGatewayWithCertificate", 
            path: "/wireless-gateways/{Id}/certificate", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a wireless gateway with a certificate.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to update.
    ///   - iotCertificateId: The ID of the certificate to associate with the wireless gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateWirelessGatewayWithCertificate(
        id: String,
        iotCertificateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateWirelessGatewayWithCertificateResponse {
        let input = AssociateWirelessGatewayWithCertificateRequest(
            id: id, 
            iotCertificateId: iotCertificateId
        )
        return try await self.associateWirelessGatewayWithCertificate(input, logger: logger)
    }

    /// Associates a wireless gateway with a thing.
    @Sendable
    @inlinable
    public func associateWirelessGatewayWithThing(_ input: AssociateWirelessGatewayWithThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateWirelessGatewayWithThingResponse {
        try await self.client.execute(
            operation: "AssociateWirelessGatewayWithThing", 
            path: "/wireless-gateways/{Id}/thing", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a wireless gateway with a thing.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to update.
    ///   - thingArn: The ARN of the thing to associate with the wireless gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateWirelessGatewayWithThing(
        id: String,
        thingArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateWirelessGatewayWithThingResponse {
        let input = AssociateWirelessGatewayWithThingRequest(
            id: id, 
            thingArn: thingArn
        )
        return try await self.associateWirelessGatewayWithThing(input, logger: logger)
    }

    /// Cancels an existing multicast group session.
    @Sendable
    @inlinable
    public func cancelMulticastGroupSession(_ input: CancelMulticastGroupSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelMulticastGroupSessionResponse {
        try await self.client.execute(
            operation: "CancelMulticastGroupSession", 
            path: "/multicast-groups/{Id}/session", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels an existing multicast group session.
    ///
    /// Parameters:
    ///   - id: 
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelMulticastGroupSession(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelMulticastGroupSessionResponse {
        let input = CancelMulticastGroupSessionRequest(
            id: id
        )
        return try await self.cancelMulticastGroupSession(input, logger: logger)
    }

    /// Creates a new destination that maps a device message to an AWS IoT rule.
    @Sendable
    @inlinable
    public func createDestination(_ input: CreateDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDestinationResponse {
        try await self.client.execute(
            operation: "CreateDestination", 
            path: "/destinations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new destination that maps a device message to an AWS IoT rule.
    ///
    /// Parameters:
    ///   - clientRequestToken: Each resource must have a unique client request token. The client token is used to implement idempotency. It ensures that the request completes no more than one time. If you retry a request with the same token and the same parameters, the request will complete successfully. However, if you try to create a new resource using the same token but different parameters, an HTTP 409 conflict occurs. If you omit this value, AWS SDKs will automatically generate a unique client request. For more information about idempotency, see Ensuring idempotency in Amazon EC2 API requests.
    ///   - description: The description of the new resource.
    ///   - expression: The rule name or topic rule to send messages to.
    ///   - expressionType: The type of value in Expression.
    ///   - name: The name of the new resource.
    ///   - roleArn: The ARN of the IAM Role that authorizes the destination.
    ///   - tags: The tags to attach to the new destination. Tags are metadata that you can use to manage a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDestination(
        clientRequestToken: String? = CreateDestinationRequest.idempotencyToken(),
        description: String? = nil,
        expression: String,
        expressionType: ExpressionType,
        name: String,
        roleArn: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDestinationResponse {
        let input = CreateDestinationRequest(
            clientRequestToken: clientRequestToken, 
            description: description, 
            expression: expression, 
            expressionType: expressionType, 
            name: name, 
            roleArn: roleArn, 
            tags: tags
        )
        return try await self.createDestination(input, logger: logger)
    }

    /// Creates a new device profile.
    @Sendable
    @inlinable
    public func createDeviceProfile(_ input: CreateDeviceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDeviceProfileResponse {
        try await self.client.execute(
            operation: "CreateDeviceProfile", 
            path: "/device-profiles", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new device profile.
    ///
    /// Parameters:
    ///   - clientRequestToken: Each resource must have a unique client request token. The client token is used to implement idempotency. It ensures that the request completes no more than one time. If you retry a request with the same token and the same parameters, the request will complete successfully. However, if you try to create a new resource using the same token but different parameters, an HTTP 409 conflict occurs. If you omit this value, AWS SDKs will automatically generate a unique client request. For more information about idempotency, see Ensuring idempotency in Amazon EC2 API requests.
    ///   - loRaWAN: The device profile information to use to create the device profile.
    ///   - name: The name of the new resource.  The following special characters aren't accepted: <>^#~$
    ///   - sidewalk: The Sidewalk-related information for creating the Sidewalk device profile.
    ///   - tags: The tags to attach to the new device profile. Tags are metadata that you can use to manage a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDeviceProfile(
        clientRequestToken: String? = CreateDeviceProfileRequest.idempotencyToken(),
        loRaWAN: LoRaWANDeviceProfile? = nil,
        name: String? = nil,
        sidewalk: SidewalkCreateDeviceProfile? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDeviceProfileResponse {
        let input = CreateDeviceProfileRequest(
            clientRequestToken: clientRequestToken, 
            loRaWAN: loRaWAN, 
            name: name, 
            sidewalk: sidewalk, 
            tags: tags
        )
        return try await self.createDeviceProfile(input, logger: logger)
    }

    /// Creates a FUOTA task.
    @Sendable
    @inlinable
    public func createFuotaTask(_ input: CreateFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateFuotaTaskResponse {
        try await self.client.execute(
            operation: "CreateFuotaTask", 
            path: "/fuota-tasks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a FUOTA task.
    ///
    /// Parameters:
    ///   - clientRequestToken: 
    ///   - description: 
    ///   - descriptor: 
    ///   - firmwareUpdateImage: 
    ///   - firmwareUpdateRole: 
    ///   - fragmentIntervalMS: 
    ///   - fragmentSizeBytes: 
    ///   - loRaWAN: 
    ///   - name: 
    ///   - redundancyPercent: 
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createFuotaTask(
        clientRequestToken: String? = CreateFuotaTaskRequest.idempotencyToken(),
        description: String? = nil,
        descriptor: String? = nil,
        firmwareUpdateImage: String,
        firmwareUpdateRole: String,
        fragmentIntervalMS: Int? = nil,
        fragmentSizeBytes: Int? = nil,
        loRaWAN: LoRaWANFuotaTask? = nil,
        name: String? = nil,
        redundancyPercent: Int? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFuotaTaskResponse {
        let input = CreateFuotaTaskRequest(
            clientRequestToken: clientRequestToken, 
            description: description, 
            descriptor: descriptor, 
            firmwareUpdateImage: firmwareUpdateImage, 
            firmwareUpdateRole: firmwareUpdateRole, 
            fragmentIntervalMS: fragmentIntervalMS, 
            fragmentSizeBytes: fragmentSizeBytes, 
            loRaWAN: loRaWAN, 
            name: name, 
            redundancyPercent: redundancyPercent, 
            tags: tags
        )
        return try await self.createFuotaTask(input, logger: logger)
    }

    /// Creates a multicast group.
    @Sendable
    @inlinable
    public func createMulticastGroup(_ input: CreateMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMulticastGroupResponse {
        try await self.client.execute(
            operation: "CreateMulticastGroup", 
            path: "/multicast-groups", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a multicast group.
    ///
    /// Parameters:
    ///   - clientRequestToken: Each resource must have a unique client request token. The client token is used to implement idempotency. It ensures that the request completes no more than one time. If you retry a request with the same token and the same parameters, the request will complete successfully. However, if you try to create a new resource using the same token but different parameters, an HTTP 409 conflict occurs. If you omit this value, AWS SDKs will automatically generate a unique client request. For more information about idempotency, see Ensuring idempotency in Amazon EC2 API requests.
    ///   - description: The description of the multicast group.
    ///   - loRaWAN: 
    ///   - name: 
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createMulticastGroup(
        clientRequestToken: String? = CreateMulticastGroupRequest.idempotencyToken(),
        description: String? = nil,
        loRaWAN: LoRaWANMulticast,
        name: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMulticastGroupResponse {
        let input = CreateMulticastGroupRequest(
            clientRequestToken: clientRequestToken, 
            description: description, 
            loRaWAN: loRaWAN, 
            name: name, 
            tags: tags
        )
        return try await self.createMulticastGroup(input, logger: logger)
    }

    /// Creates a new network analyzer configuration.
    @Sendable
    @inlinable
    public func createNetworkAnalyzerConfiguration(_ input: CreateNetworkAnalyzerConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNetworkAnalyzerConfigurationResponse {
        try await self.client.execute(
            operation: "CreateNetworkAnalyzerConfiguration", 
            path: "/network-analyzer-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new network analyzer configuration.
    ///
    /// Parameters:
    ///   - clientRequestToken: 
    ///   - description: 
    ///   - multicastGroups: Multicast Group resources to add to the network analyzer configruation. Provide the MulticastGroupId of the resource to add in the input array.
    ///   - name: 
    ///   - tags: 
    ///   - traceContent: 
    ///   - wirelessDevices: Wireless device resources to add to the network analyzer configuration. Provide the WirelessDeviceId of the resource to add in the input array.
    ///   - wirelessGateways: Wireless gateway resources to add to the network analyzer configuration. Provide the WirelessGatewayId of the resource to add in the input array.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNetworkAnalyzerConfiguration(
        clientRequestToken: String? = CreateNetworkAnalyzerConfigurationRequest.idempotencyToken(),
        description: String? = nil,
        multicastGroups: [String]? = nil,
        name: String,
        tags: [Tag]? = nil,
        traceContent: TraceContent? = nil,
        wirelessDevices: [String]? = nil,
        wirelessGateways: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNetworkAnalyzerConfigurationResponse {
        let input = CreateNetworkAnalyzerConfigurationRequest(
            clientRequestToken: clientRequestToken, 
            description: description, 
            multicastGroups: multicastGroups, 
            name: name, 
            tags: tags, 
            traceContent: traceContent, 
            wirelessDevices: wirelessDevices, 
            wirelessGateways: wirelessGateways
        )
        return try await self.createNetworkAnalyzerConfiguration(input, logger: logger)
    }

    /// Creates a new service profile.
    @Sendable
    @inlinable
    public func createServiceProfile(_ input: CreateServiceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateServiceProfileResponse {
        try await self.client.execute(
            operation: "CreateServiceProfile", 
            path: "/service-profiles", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new service profile.
    ///
    /// Parameters:
    ///   - clientRequestToken: Each resource must have a unique client request token. The client token is used to implement idempotency. It ensures that the request completes no more than one time. If you retry a request with the same token and the same parameters, the request will complete successfully. However, if you try to create a new resource using the same token but different parameters, an HTTP 409 conflict occurs. If you omit this value, AWS SDKs will automatically generate a unique client request. For more information about idempotency, see Ensuring idempotency in Amazon EC2 API requests.
    ///   - loRaWAN: The service profile information to use to create the service profile.
    ///   - name: The name of the new resource.  The following special characters aren't accepted: <>^#~$
    ///   - tags: The tags to attach to the new service profile. Tags are metadata that you can use to manage a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createServiceProfile(
        clientRequestToken: String? = CreateServiceProfileRequest.idempotencyToken(),
        loRaWAN: LoRaWANServiceProfile? = nil,
        name: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateServiceProfileResponse {
        let input = CreateServiceProfileRequest(
            clientRequestToken: clientRequestToken, 
            loRaWAN: loRaWAN, 
            name: name, 
            tags: tags
        )
        return try await self.createServiceProfile(input, logger: logger)
    }

    /// Provisions a wireless device.
    @Sendable
    @inlinable
    public func createWirelessDevice(_ input: CreateWirelessDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWirelessDeviceResponse {
        try await self.client.execute(
            operation: "CreateWirelessDevice", 
            path: "/wireless-devices", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provisions a wireless device.
    ///
    /// Parameters:
    ///   - clientRequestToken: Each resource must have a unique client request token. The client token is used to implement idempotency. It ensures that the request completes no more than one time. If you retry a request with the same token and the same parameters, the request will complete successfully. However, if you try to create a new resource using the same token but different parameters, an HTTP 409 conflict occurs. If you omit this value, AWS SDKs will automatically generate a unique client request. For more information about idempotency, see Ensuring idempotency in Amazon EC2 API requests.
    ///   - description: The description of the new resource.
    ///   - destinationName: The name of the destination to assign to the new wireless device.
    ///   - loRaWAN: The device configuration information to use to create the wireless device.
    ///   - name: The name of the new resource.  The following special characters aren't accepted: <>^#~$
    ///   - positioning: FPort values for the GNSS, stream, and ClockSync functions of the positioning information.
    ///   - sidewalk: The device configuration information to use to create the Sidewalk device.
    ///   - tags: The tags to attach to the new wireless device. Tags are metadata that you can use to manage a resource.
    ///   - type: The wireless device type.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWirelessDevice(
        clientRequestToken: String? = CreateWirelessDeviceRequest.idempotencyToken(),
        description: String? = nil,
        destinationName: String,
        loRaWAN: LoRaWANDevice? = nil,
        name: String? = nil,
        positioning: PositioningConfigStatus? = nil,
        sidewalk: SidewalkCreateWirelessDevice? = nil,
        tags: [Tag]? = nil,
        type: WirelessDeviceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWirelessDeviceResponse {
        let input = CreateWirelessDeviceRequest(
            clientRequestToken: clientRequestToken, 
            description: description, 
            destinationName: destinationName, 
            loRaWAN: loRaWAN, 
            name: name, 
            positioning: positioning, 
            sidewalk: sidewalk, 
            tags: tags, 
            type: type
        )
        return try await self.createWirelessDevice(input, logger: logger)
    }

    /// Provisions a wireless gateway.  When provisioning a wireless gateway, you might run into duplication errors for the following reasons.   If you specify a GatewayEui value that already exists.   If you used a ClientRequestToken with the same parameters within the last 10 minutes.   To avoid this error, make sure that you use unique identifiers and parameters for each request within the specified time period.
    @Sendable
    @inlinable
    public func createWirelessGateway(_ input: CreateWirelessGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWirelessGatewayResponse {
        try await self.client.execute(
            operation: "CreateWirelessGateway", 
            path: "/wireless-gateways", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provisions a wireless gateway.  When provisioning a wireless gateway, you might run into duplication errors for the following reasons.   If you specify a GatewayEui value that already exists.   If you used a ClientRequestToken with the same parameters within the last 10 minutes.   To avoid this error, make sure that you use unique identifiers and parameters for each request within the specified time period.
    ///
    /// Parameters:
    ///   - clientRequestToken: Each resource must have a unique client request token. The client token is used to implement idempotency. It ensures that the request completes no more than one time. If you retry a request with the same token and the same parameters, the request will complete successfully. However, if you try to create a new resource using the same token but different parameters, an HTTP 409 conflict occurs. If you omit this value, AWS SDKs will automatically generate a unique client request. For more information about idempotency, see Ensuring idempotency in Amazon EC2 API requests.
    ///   - description: The description of the new resource.
    ///   - loRaWAN: The gateway configuration information to use to create the wireless gateway.
    ///   - name: The name of the new resource.  The following special characters aren't accepted: <>^#~$
    ///   - tags: The tags to attach to the new wireless gateway. Tags are metadata that you can use to manage a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWirelessGateway(
        clientRequestToken: String? = CreateWirelessGatewayRequest.idempotencyToken(),
        description: String? = nil,
        loRaWAN: LoRaWANGateway,
        name: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWirelessGatewayResponse {
        let input = CreateWirelessGatewayRequest(
            clientRequestToken: clientRequestToken, 
            description: description, 
            loRaWAN: loRaWAN, 
            name: name, 
            tags: tags
        )
        return try await self.createWirelessGateway(input, logger: logger)
    }

    /// Creates a task for a wireless gateway.
    @Sendable
    @inlinable
    public func createWirelessGatewayTask(_ input: CreateWirelessGatewayTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWirelessGatewayTaskResponse {
        try await self.client.execute(
            operation: "CreateWirelessGatewayTask", 
            path: "/wireless-gateways/{Id}/tasks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a task for a wireless gateway.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to update.
    ///   - wirelessGatewayTaskDefinitionId: The ID of the WirelessGatewayTaskDefinition.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWirelessGatewayTask(
        id: String,
        wirelessGatewayTaskDefinitionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWirelessGatewayTaskResponse {
        let input = CreateWirelessGatewayTaskRequest(
            id: id, 
            wirelessGatewayTaskDefinitionId: wirelessGatewayTaskDefinitionId
        )
        return try await self.createWirelessGatewayTask(input, logger: logger)
    }

    /// Creates a gateway task definition.
    @Sendable
    @inlinable
    public func createWirelessGatewayTaskDefinition(_ input: CreateWirelessGatewayTaskDefinitionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWirelessGatewayTaskDefinitionResponse {
        try await self.client.execute(
            operation: "CreateWirelessGatewayTaskDefinition", 
            path: "/wireless-gateway-task-definitions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a gateway task definition.
    ///
    /// Parameters:
    ///   - autoCreateTasks: Whether to automatically create tasks using this task definition for all gateways with the specified current version. If false, the task must me created by calling CreateWirelessGatewayTask.
    ///   - clientRequestToken: Each resource must have a unique client request token. The client token is used to implement idempotency. It ensures that the request completes no more than one time. If you retry a request with the same token and the same parameters, the request will complete successfully. However, if you try to create a new resource using the same token but different parameters, an HTTP 409 conflict occurs. If you omit this value, AWS SDKs will automatically generate a unique client request. For more information about idempotency, see Ensuring idempotency in Amazon EC2 API requests.
    ///   - name: The name of the new resource.
    ///   - tags: The tags to attach to the specified resource. Tags are metadata that you can use to manage a resource.
    ///   - update: Information about the gateways to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWirelessGatewayTaskDefinition(
        autoCreateTasks: Bool = false,
        clientRequestToken: String? = CreateWirelessGatewayTaskDefinitionRequest.idempotencyToken(),
        name: String? = nil,
        tags: [Tag]? = nil,
        update: UpdateWirelessGatewayTaskCreate? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWirelessGatewayTaskDefinitionResponse {
        let input = CreateWirelessGatewayTaskDefinitionRequest(
            autoCreateTasks: autoCreateTasks, 
            clientRequestToken: clientRequestToken, 
            name: name, 
            tags: tags, 
            update: update
        )
        return try await self.createWirelessGatewayTaskDefinition(input, logger: logger)
    }

    /// Deletes a destination.
    @Sendable
    @inlinable
    public func deleteDestination(_ input: DeleteDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDestinationResponse {
        try await self.client.execute(
            operation: "DeleteDestination", 
            path: "/destinations/{Name}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a destination.
    ///
    /// Parameters:
    ///   - name: The name of the resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDestination(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDestinationResponse {
        let input = DeleteDestinationRequest(
            name: name
        )
        return try await self.deleteDestination(input, logger: logger)
    }

    /// Deletes a device profile.
    @Sendable
    @inlinable
    public func deleteDeviceProfile(_ input: DeleteDeviceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDeviceProfileResponse {
        try await self.client.execute(
            operation: "DeleteDeviceProfile", 
            path: "/device-profiles/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a device profile.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDeviceProfile(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDeviceProfileResponse {
        let input = DeleteDeviceProfileRequest(
            id: id
        )
        return try await self.deleteDeviceProfile(input, logger: logger)
    }

    /// Deletes a FUOTA task.
    @Sendable
    @inlinable
    public func deleteFuotaTask(_ input: DeleteFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteFuotaTaskResponse {
        try await self.client.execute(
            operation: "DeleteFuotaTask", 
            path: "/fuota-tasks/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFuotaTask(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteFuotaTaskResponse {
        let input = DeleteFuotaTaskRequest(
            id: id
        )
        return try await self.deleteFuotaTask(input, logger: logger)
    }

    /// Deletes a multicast group if it is not in use by a FUOTA task.
    @Sendable
    @inlinable
    public func deleteMulticastGroup(_ input: DeleteMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMulticastGroupResponse {
        try await self.client.execute(
            operation: "DeleteMulticastGroup", 
            path: "/multicast-groups/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a multicast group if it is not in use by a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMulticastGroup(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMulticastGroupResponse {
        let input = DeleteMulticastGroupRequest(
            id: id
        )
        return try await self.deleteMulticastGroup(input, logger: logger)
    }

    /// Deletes a network analyzer configuration.
    @Sendable
    @inlinable
    public func deleteNetworkAnalyzerConfiguration(_ input: DeleteNetworkAnalyzerConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNetworkAnalyzerConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteNetworkAnalyzerConfiguration", 
            path: "/network-analyzer-configurations/{ConfigurationName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a network analyzer configuration.
    ///
    /// Parameters:
    ///   - configurationName: 
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNetworkAnalyzerConfiguration(
        configurationName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNetworkAnalyzerConfigurationResponse {
        let input = DeleteNetworkAnalyzerConfigurationRequest(
            configurationName: configurationName
        )
        return try await self.deleteNetworkAnalyzerConfiguration(input, logger: logger)
    }

    /// Remove queued messages from the downlink queue.
    @Sendable
    @inlinable
    public func deleteQueuedMessages(_ input: DeleteQueuedMessagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteQueuedMessagesResponse {
        try await self.client.execute(
            operation: "DeleteQueuedMessages", 
            path: "/wireless-devices/{Id}/data", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Remove queued messages from the downlink queue.
    ///
    /// Parameters:
    ///   - id: The ID of a given wireless device for which downlink messages will be deleted.
    ///   - messageId: If message ID is "*", it cleares the entire downlink queue for a given device, specified by the wireless device ID. Otherwise, the downlink message with the specified message ID will be deleted.
    ///   - wirelessDeviceType: The wireless device type, which can be either Sidewalk or LoRaWAN.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteQueuedMessages(
        id: String,
        messageId: String,
        wirelessDeviceType: WirelessDeviceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteQueuedMessagesResponse {
        let input = DeleteQueuedMessagesRequest(
            id: id, 
            messageId: messageId, 
            wirelessDeviceType: wirelessDeviceType
        )
        return try await self.deleteQueuedMessages(input, logger: logger)
    }

    /// Deletes a service profile.
    @Sendable
    @inlinable
    public func deleteServiceProfile(_ input: DeleteServiceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteServiceProfileResponse {
        try await self.client.execute(
            operation: "DeleteServiceProfile", 
            path: "/service-profiles/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a service profile.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteServiceProfile(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteServiceProfileResponse {
        let input = DeleteServiceProfileRequest(
            id: id
        )
        return try await self.deleteServiceProfile(input, logger: logger)
    }

    /// Deletes a wireless device.
    @Sendable
    @inlinable
    public func deleteWirelessDevice(_ input: DeleteWirelessDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWirelessDeviceResponse {
        try await self.client.execute(
            operation: "DeleteWirelessDevice", 
            path: "/wireless-devices/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a wireless device.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWirelessDevice(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWirelessDeviceResponse {
        let input = DeleteWirelessDeviceRequest(
            id: id
        )
        return try await self.deleteWirelessDevice(input, logger: logger)
    }

    /// Delete an import task.
    @Sendable
    @inlinable
    public func deleteWirelessDeviceImportTask(_ input: DeleteWirelessDeviceImportTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWirelessDeviceImportTaskResponse {
        try await self.client.execute(
            operation: "DeleteWirelessDeviceImportTask", 
            path: "/wireless_device_import_task/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete an import task.
    ///
    /// Parameters:
    ///   - id: The unique identifier of the import task to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWirelessDeviceImportTask(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWirelessDeviceImportTaskResponse {
        let input = DeleteWirelessDeviceImportTaskRequest(
            id: id
        )
        return try await self.deleteWirelessDeviceImportTask(input, logger: logger)
    }

    /// Deletes a wireless gateway.  When deleting a wireless gateway, you might run into duplication errors for the following reasons.   If you specify a GatewayEui value that already exists.   If you used a ClientRequestToken with the same parameters within the last 10 minutes.   To avoid this error, make sure that you use unique identifiers and parameters for each request within the specified time period.
    @Sendable
    @inlinable
    public func deleteWirelessGateway(_ input: DeleteWirelessGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWirelessGatewayResponse {
        try await self.client.execute(
            operation: "DeleteWirelessGateway", 
            path: "/wireless-gateways/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a wireless gateway.  When deleting a wireless gateway, you might run into duplication errors for the following reasons.   If you specify a GatewayEui value that already exists.   If you used a ClientRequestToken with the same parameters within the last 10 minutes.   To avoid this error, make sure that you use unique identifiers and parameters for each request within the specified time period.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWirelessGateway(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWirelessGatewayResponse {
        let input = DeleteWirelessGatewayRequest(
            id: id
        )
        return try await self.deleteWirelessGateway(input, logger: logger)
    }

    /// Deletes a wireless gateway task.
    @Sendable
    @inlinable
    public func deleteWirelessGatewayTask(_ input: DeleteWirelessGatewayTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWirelessGatewayTaskResponse {
        try await self.client.execute(
            operation: "DeleteWirelessGatewayTask", 
            path: "/wireless-gateways/{Id}/tasks", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a wireless gateway task.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWirelessGatewayTask(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWirelessGatewayTaskResponse {
        let input = DeleteWirelessGatewayTaskRequest(
            id: id
        )
        return try await self.deleteWirelessGatewayTask(input, logger: logger)
    }

    /// Deletes a wireless gateway task definition. Deleting this task definition does not affect tasks that are currently in progress.
    @Sendable
    @inlinable
    public func deleteWirelessGatewayTaskDefinition(_ input: DeleteWirelessGatewayTaskDefinitionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWirelessGatewayTaskDefinitionResponse {
        try await self.client.execute(
            operation: "DeleteWirelessGatewayTaskDefinition", 
            path: "/wireless-gateway-task-definitions/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a wireless gateway task definition. Deleting this task definition does not affect tasks that are currently in progress.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWirelessGatewayTaskDefinition(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWirelessGatewayTaskDefinitionResponse {
        let input = DeleteWirelessGatewayTaskDefinitionRequest(
            id: id
        )
        return try await self.deleteWirelessGatewayTaskDefinition(input, logger: logger)
    }

    /// Deregister a wireless device from AWS IoT Wireless.
    @Sendable
    @inlinable
    public func deregisterWirelessDevice(_ input: DeregisterWirelessDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeregisterWirelessDeviceResponse {
        try await self.client.execute(
            operation: "DeregisterWirelessDevice", 
            path: "/wireless-devices/{Identifier}/deregister", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deregister a wireless device from AWS IoT Wireless.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the wireless device to deregister from AWS IoT Wireless.
    ///   - wirelessDeviceType: The type of wireless device to deregister from AWS IoT Wireless, which can be LoRaWAN or Sidewalk.
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterWirelessDevice(
        identifier: String,
        wirelessDeviceType: WirelessDeviceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeregisterWirelessDeviceResponse {
        let input = DeregisterWirelessDeviceRequest(
            identifier: identifier, 
            wirelessDeviceType: wirelessDeviceType
        )
        return try await self.deregisterWirelessDevice(input, logger: logger)
    }

    /// Disassociates your AWS account from a partner account. If PartnerAccountId and PartnerType are null, disassociates your AWS account from all partner accounts.
    @Sendable
    @inlinable
    public func disassociateAwsAccountFromPartnerAccount(_ input: DisassociateAwsAccountFromPartnerAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateAwsAccountFromPartnerAccountResponse {
        try await self.client.execute(
            operation: "DisassociateAwsAccountFromPartnerAccount", 
            path: "/partner-accounts/{PartnerAccountId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates your AWS account from a partner account. If PartnerAccountId and PartnerType are null, disassociates your AWS account from all partner accounts.
    ///
    /// Parameters:
    ///   - partnerAccountId: The partner account ID to disassociate from the AWS account.
    ///   - partnerType: The partner type.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateAwsAccountFromPartnerAccount(
        partnerAccountId: String,
        partnerType: PartnerType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateAwsAccountFromPartnerAccountResponse {
        let input = DisassociateAwsAccountFromPartnerAccountRequest(
            partnerAccountId: partnerAccountId, 
            partnerType: partnerType
        )
        return try await self.disassociateAwsAccountFromPartnerAccount(input, logger: logger)
    }

    /// Disassociates a multicast group from a FUOTA task.
    @Sendable
    @inlinable
    public func disassociateMulticastGroupFromFuotaTask(_ input: DisassociateMulticastGroupFromFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateMulticastGroupFromFuotaTaskResponse {
        try await self.client.execute(
            operation: "DisassociateMulticastGroupFromFuotaTask", 
            path: "/fuota-tasks/{Id}/multicast-groups/{MulticastGroupId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a multicast group from a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - multicastGroupId: 
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateMulticastGroupFromFuotaTask(
        id: String,
        multicastGroupId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateMulticastGroupFromFuotaTaskResponse {
        let input = DisassociateMulticastGroupFromFuotaTaskRequest(
            id: id, 
            multicastGroupId: multicastGroupId
        )
        return try await self.disassociateMulticastGroupFromFuotaTask(input, logger: logger)
    }

    /// Disassociates a wireless device from a FUOTA task.
    @Sendable
    @inlinable
    public func disassociateWirelessDeviceFromFuotaTask(_ input: DisassociateWirelessDeviceFromFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateWirelessDeviceFromFuotaTaskResponse {
        try await self.client.execute(
            operation: "DisassociateWirelessDeviceFromFuotaTask", 
            path: "/fuota-tasks/{Id}/wireless-devices/{WirelessDeviceId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a wireless device from a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - wirelessDeviceId: 
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateWirelessDeviceFromFuotaTask(
        id: String,
        wirelessDeviceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateWirelessDeviceFromFuotaTaskResponse {
        let input = DisassociateWirelessDeviceFromFuotaTaskRequest(
            id: id, 
            wirelessDeviceId: wirelessDeviceId
        )
        return try await self.disassociateWirelessDeviceFromFuotaTask(input, logger: logger)
    }

    /// Disassociates a wireless device from a multicast group.
    @Sendable
    @inlinable
    public func disassociateWirelessDeviceFromMulticastGroup(_ input: DisassociateWirelessDeviceFromMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateWirelessDeviceFromMulticastGroupResponse {
        try await self.client.execute(
            operation: "DisassociateWirelessDeviceFromMulticastGroup", 
            path: "/multicast-groups/{Id}/wireless-devices/{WirelessDeviceId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a wireless device from a multicast group.
    ///
    /// Parameters:
    ///   - id: 
    ///   - wirelessDeviceId: 
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateWirelessDeviceFromMulticastGroup(
        id: String,
        wirelessDeviceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateWirelessDeviceFromMulticastGroupResponse {
        let input = DisassociateWirelessDeviceFromMulticastGroupRequest(
            id: id, 
            wirelessDeviceId: wirelessDeviceId
        )
        return try await self.disassociateWirelessDeviceFromMulticastGroup(input, logger: logger)
    }

    /// Disassociates a wireless device from its currently associated thing.
    @Sendable
    @inlinable
    public func disassociateWirelessDeviceFromThing(_ input: DisassociateWirelessDeviceFromThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateWirelessDeviceFromThingResponse {
        try await self.client.execute(
            operation: "DisassociateWirelessDeviceFromThing", 
            path: "/wireless-devices/{Id}/thing", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a wireless device from its currently associated thing.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateWirelessDeviceFromThing(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateWirelessDeviceFromThingResponse {
        let input = DisassociateWirelessDeviceFromThingRequest(
            id: id
        )
        return try await self.disassociateWirelessDeviceFromThing(input, logger: logger)
    }

    /// Disassociates a wireless gateway from its currently associated certificate.
    @Sendable
    @inlinable
    public func disassociateWirelessGatewayFromCertificate(_ input: DisassociateWirelessGatewayFromCertificateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateWirelessGatewayFromCertificateResponse {
        try await self.client.execute(
            operation: "DisassociateWirelessGatewayFromCertificate", 
            path: "/wireless-gateways/{Id}/certificate", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a wireless gateway from its currently associated certificate.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateWirelessGatewayFromCertificate(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateWirelessGatewayFromCertificateResponse {
        let input = DisassociateWirelessGatewayFromCertificateRequest(
            id: id
        )
        return try await self.disassociateWirelessGatewayFromCertificate(input, logger: logger)
    }

    /// Disassociates a wireless gateway from its currently associated thing.
    @Sendable
    @inlinable
    public func disassociateWirelessGatewayFromThing(_ input: DisassociateWirelessGatewayFromThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateWirelessGatewayFromThingResponse {
        try await self.client.execute(
            operation: "DisassociateWirelessGatewayFromThing", 
            path: "/wireless-gateways/{Id}/thing", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a wireless gateway from its currently associated thing.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateWirelessGatewayFromThing(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateWirelessGatewayFromThingResponse {
        let input = DisassociateWirelessGatewayFromThingRequest(
            id: id
        )
        return try await self.disassociateWirelessGatewayFromThing(input, logger: logger)
    }

    /// Gets information about a destination.
    @Sendable
    @inlinable
    public func getDestination(_ input: GetDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDestinationResponse {
        try await self.client.execute(
            operation: "GetDestination", 
            path: "/destinations/{Name}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a destination.
    ///
    /// Parameters:
    ///   - name: The name of the resource to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDestination(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDestinationResponse {
        let input = GetDestinationRequest(
            name: name
        )
        return try await self.getDestination(input, logger: logger)
    }

    /// Gets information about a device profile.
    @Sendable
    @inlinable
    public func getDeviceProfile(_ input: GetDeviceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDeviceProfileResponse {
        try await self.client.execute(
            operation: "GetDeviceProfile", 
            path: "/device-profiles/{Id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a device profile.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDeviceProfile(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceProfileResponse {
        let input = GetDeviceProfileRequest(
            id: id
        )
        return try await self.getDeviceProfile(input, logger: logger)
    }

    /// Get the event configuration based on resource types.
    @Sendable
    @inlinable
    public func getEventConfigurationByResourceTypes(_ input: GetEventConfigurationByResourceTypesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEventConfigurationByResourceTypesResponse {
        try await self.client.execute(
            operation: "GetEventConfigurationByResourceTypes", 
            path: "/event-configurations-resource-types", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the event configuration based on resource types.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getEventConfigurationByResourceTypes(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEventConfigurationByResourceTypesResponse {
        let input = GetEventConfigurationByResourceTypesRequest(
        )
        return try await self.getEventConfigurationByResourceTypes(input, logger: logger)
    }

    /// Gets information about a FUOTA task.
    @Sendable
    @inlinable
    public func getFuotaTask(_ input: GetFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFuotaTaskResponse {
        try await self.client.execute(
            operation: "GetFuotaTask", 
            path: "/fuota-tasks/{Id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - logger: Logger use during operation
    @inlinable
    public func getFuotaTask(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFuotaTaskResponse {
        let input = GetFuotaTaskRequest(
            id: id
        )
        return try await self.getFuotaTask(input, logger: logger)
    }

    /// Returns current default log levels or log levels by resource types. Based on the resource type, log levels can be returned for wireless device, wireless gateway, or FUOTA task log options.
    @Sendable
    @inlinable
    public func getLogLevelsByResourceTypes(_ input: GetLogLevelsByResourceTypesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLogLevelsByResourceTypesResponse {
        try await self.client.execute(
            operation: "GetLogLevelsByResourceTypes", 
            path: "/log-levels", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns current default log levels or log levels by resource types. Based on the resource type, log levels can be returned for wireless device, wireless gateway, or FUOTA task log options.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getLogLevelsByResourceTypes(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLogLevelsByResourceTypesResponse {
        let input = GetLogLevelsByResourceTypesRequest(
        )
        return try await self.getLogLevelsByResourceTypes(input, logger: logger)
    }

    /// Get the metric configuration status for this AWS account.
    @Sendable
    @inlinable
    public func getMetricConfiguration(_ input: GetMetricConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMetricConfigurationResponse {
        try await self.client.execute(
            operation: "GetMetricConfiguration", 
            path: "/metric-configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the metric configuration status for this AWS account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getMetricConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMetricConfigurationResponse {
        let input = GetMetricConfigurationRequest(
        )
        return try await self.getMetricConfiguration(input, logger: logger)
    }

    /// Get the summary metrics for this AWS account.
    @Sendable
    @inlinable
    public func getMetrics(_ input: GetMetricsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMetricsResponse {
        try await self.client.execute(
            operation: "GetMetrics", 
            path: "/metrics", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the summary metrics for this AWS account.
    ///
    /// Parameters:
    ///   - summaryMetricQueries: The list of queries to retrieve the summary metrics.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMetrics(
        summaryMetricQueries: [SummaryMetricQuery]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMetricsResponse {
        let input = GetMetricsRequest(
            summaryMetricQueries: summaryMetricQueries
        )
        return try await self.getMetrics(input, logger: logger)
    }

    /// Gets information about a multicast group.
    @Sendable
    @inlinable
    public func getMulticastGroup(_ input: GetMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMulticastGroupResponse {
        try await self.client.execute(
            operation: "GetMulticastGroup", 
            path: "/multicast-groups/{Id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a multicast group.
    ///
    /// Parameters:
    ///   - id: 
    ///   - logger: Logger use during operation
    @inlinable
    public func getMulticastGroup(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMulticastGroupResponse {
        let input = GetMulticastGroupRequest(
            id: id
        )
        return try await self.getMulticastGroup(input, logger: logger)
    }

    /// Gets information about a multicast group session.
    @Sendable
    @inlinable
    public func getMulticastGroupSession(_ input: GetMulticastGroupSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMulticastGroupSessionResponse {
        try await self.client.execute(
            operation: "GetMulticastGroupSession", 
            path: "/multicast-groups/{Id}/session", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a multicast group session.
    ///
    /// Parameters:
    ///   - id: 
    ///   - logger: Logger use during operation
    @inlinable
    public func getMulticastGroupSession(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMulticastGroupSessionResponse {
        let input = GetMulticastGroupSessionRequest(
            id: id
        )
        return try await self.getMulticastGroupSession(input, logger: logger)
    }

    /// Get network analyzer configuration.
    @Sendable
    @inlinable
    public func getNetworkAnalyzerConfiguration(_ input: GetNetworkAnalyzerConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkAnalyzerConfigurationResponse {
        try await self.client.execute(
            operation: "GetNetworkAnalyzerConfiguration", 
            path: "/network-analyzer-configurations/{ConfigurationName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get network analyzer configuration.
    ///
    /// Parameters:
    ///   - configurationName: 
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkAnalyzerConfiguration(
        configurationName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkAnalyzerConfigurationResponse {
        let input = GetNetworkAnalyzerConfigurationRequest(
            configurationName: configurationName
        )
        return try await self.getNetworkAnalyzerConfiguration(input, logger: logger)
    }

    /// Gets information about a partner account. If PartnerAccountId and PartnerType are null, returns all partner accounts.
    @Sendable
    @inlinable
    public func getPartnerAccount(_ input: GetPartnerAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPartnerAccountResponse {
        try await self.client.execute(
            operation: "GetPartnerAccount", 
            path: "/partner-accounts/{PartnerAccountId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a partner account. If PartnerAccountId and PartnerType are null, returns all partner accounts.
    ///
    /// Parameters:
    ///   - partnerAccountId: The partner account ID to disassociate from the AWS account.
    ///   - partnerType: The partner type.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPartnerAccount(
        partnerAccountId: String,
        partnerType: PartnerType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPartnerAccountResponse {
        let input = GetPartnerAccountRequest(
            partnerAccountId: partnerAccountId, 
            partnerType: partnerType
        )
        return try await self.getPartnerAccount(input, logger: logger)
    }

    /// Get the position information for a given resource.  This action is no longer supported. Calls to retrieve the position information should use the GetResourcePosition API operation instead.
    @available(*, deprecated, message: "This operation is no longer supported.")
    @Sendable
    @inlinable
    public func getPosition(_ input: GetPositionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPositionResponse {
        try await self.client.execute(
            operation: "GetPosition", 
            path: "/positions/{ResourceIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the position information for a given resource.  This action is no longer supported. Calls to retrieve the position information should use the GetResourcePosition API operation instead.
    ///
    /// Parameters:
    ///   - resourceIdentifier: Resource identifier used to retrieve the position information.
    ///   - resourceType: Resource type of the resource for which position information is retrieved.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "This operation is no longer supported.")
    @inlinable
    public func getPosition(
        resourceIdentifier: String,
        resourceType: PositionResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPositionResponse {
        let input = GetPositionRequest(
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType
        )
        return try await self.getPosition(input, logger: logger)
    }

    /// Get position configuration for a given resource.  This action is no longer supported. Calls to retrieve the position configuration should use the GetResourcePosition API operation instead.
    @available(*, deprecated, message: "This operation is no longer supported.")
    @Sendable
    @inlinable
    public func getPositionConfiguration(_ input: GetPositionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPositionConfigurationResponse {
        try await self.client.execute(
            operation: "GetPositionConfiguration", 
            path: "/position-configurations/{ResourceIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get position configuration for a given resource.  This action is no longer supported. Calls to retrieve the position configuration should use the GetResourcePosition API operation instead.
    ///
    /// Parameters:
    ///   - resourceIdentifier: Resource identifier used in a position configuration.
    ///   - resourceType: Resource type of the resource for which position configuration is retrieved.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "This operation is no longer supported.")
    @inlinable
    public func getPositionConfiguration(
        resourceIdentifier: String,
        resourceType: PositionResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPositionConfigurationResponse {
        let input = GetPositionConfigurationRequest(
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType
        )
        return try await self.getPositionConfiguration(input, logger: logger)
    }

    /// Get estimated position information as a payload in GeoJSON format. The payload measurement data is resolved using solvers that are provided by third-party vendors.
    @Sendable
    @inlinable
    public func getPositionEstimate(_ input: GetPositionEstimateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPositionEstimateResponse {
        try await self.client.execute(
            operation: "GetPositionEstimate", 
            path: "/position-estimate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get estimated position information as a payload in GeoJSON format. The payload measurement data is resolved using solvers that are provided by third-party vendors.
    ///
    /// Parameters:
    ///   - cellTowers: Retrieves an estimated device position by resolving measurement data from cellular radio towers. The position is resolved using HERE's cellular-based solver.
    ///   - gnss: Retrieves an estimated device position by resolving the global navigation satellite system (GNSS) scan data. The position is resolved using the GNSS solver powered by LoRa Cloud.
    ///   - ip: Retrieves an estimated device position by resolving the IP address information from the device. The position is resolved using MaxMind's IP-based solver.
    ///   - timestamp: Optional information that specifies the time when the position information will be resolved. It uses the Unix timestamp format. If not specified, the time at which the request was received will be used.
    ///   - wiFiAccessPoints: Retrieves an estimated device position by resolving WLAN measurement data. The position is resolved using HERE's Wi-Fi based solver.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPositionEstimate(
        cellTowers: CellTowers? = nil,
        gnss: Gnss? = nil,
        ip: Ip? = nil,
        timestamp: Date? = nil,
        wiFiAccessPoints: [WiFiAccessPoint]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPositionEstimateResponse {
        let input = GetPositionEstimateRequest(
            cellTowers: cellTowers, 
            gnss: gnss, 
            ip: ip, 
            timestamp: timestamp, 
            wiFiAccessPoints: wiFiAccessPoints
        )
        return try await self.getPositionEstimate(input, logger: logger)
    }

    /// Get the event configuration for a particular resource identifier.
    @Sendable
    @inlinable
    public func getResourceEventConfiguration(_ input: GetResourceEventConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourceEventConfigurationResponse {
        try await self.client.execute(
            operation: "GetResourceEventConfiguration", 
            path: "/event-configurations/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the event configuration for a particular resource identifier.
    ///
    /// Parameters:
    ///   - identifier: Resource identifier to opt in for event messaging.
    ///   - identifierType: Identifier type of the particular resource identifier for event configuration.
    ///   - partnerType: Partner type of the resource if the identifier type is PartnerAccountId.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourceEventConfiguration(
        identifier: String,
        identifierType: IdentifierType,
        partnerType: EventNotificationPartnerType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourceEventConfigurationResponse {
        let input = GetResourceEventConfigurationRequest(
            identifier: identifier, 
            identifierType: identifierType, 
            partnerType: partnerType
        )
        return try await self.getResourceEventConfiguration(input, logger: logger)
    }

    /// Fetches the log-level override, if any, for a given resource ID and resource type..
    @Sendable
    @inlinable
    public func getResourceLogLevel(_ input: GetResourceLogLevelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourceLogLevelResponse {
        try await self.client.execute(
            operation: "GetResourceLogLevel", 
            path: "/log-levels/{ResourceIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Fetches the log-level override, if any, for a given resource ID and resource type..
    ///
    /// Parameters:
    ///   - resourceIdentifier: 
    ///   - resourceType: The type of resource, which can be WirelessDevice, WirelessGateway, or FuotaTask.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourceLogLevel(
        resourceIdentifier: String,
        resourceType: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourceLogLevelResponse {
        let input = GetResourceLogLevelRequest(
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType
        )
        return try await self.getResourceLogLevel(input, logger: logger)
    }

    /// Get the position information for a given wireless device or a wireless gateway resource. The position information uses the  World Geodetic System (WGS84).
    @Sendable
    @inlinable
    public func getResourcePosition(_ input: GetResourcePositionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourcePositionResponse {
        try await self.client.execute(
            operation: "GetResourcePosition", 
            path: "/resource-positions/{ResourceIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the position information for a given wireless device or a wireless gateway resource. The position information uses the  World Geodetic System (WGS84).
    ///
    /// Parameters:
    ///   - resourceIdentifier: The identifier of the resource for which position information is retrieved. It can be the wireless device ID or the wireless gateway ID, depending on the resource type.
    ///   - resourceType: The type of resource for which position information is retrieved, which can be a wireless device or a wireless gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourcePosition(
        resourceIdentifier: String,
        resourceType: PositionResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourcePositionResponse {
        let input = GetResourcePositionRequest(
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType
        )
        return try await self.getResourcePosition(input, logger: logger)
    }

    /// Gets the account-specific endpoint for Configuration and Update Server (CUPS) protocol or LoRaWAN Network Server (LNS) connections.
    @Sendable
    @inlinable
    public func getServiceEndpoint(_ input: GetServiceEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceEndpointResponse {
        try await self.client.execute(
            operation: "GetServiceEndpoint", 
            path: "/service-endpoint", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the account-specific endpoint for Configuration and Update Server (CUPS) protocol or LoRaWAN Network Server (LNS) connections.
    ///
    /// Parameters:
    ///   - serviceType: The service type for which to get endpoint information about. Can be CUPS for the Configuration and Update Server endpoint, or LNS for the LoRaWAN Network Server endpoint.
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceEndpoint(
        serviceType: WirelessGatewayServiceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceEndpointResponse {
        let input = GetServiceEndpointRequest(
            serviceType: serviceType
        )
        return try await self.getServiceEndpoint(input, logger: logger)
    }

    /// Gets information about a service profile.
    @Sendable
    @inlinable
    public func getServiceProfile(_ input: GetServiceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceProfileResponse {
        try await self.client.execute(
            operation: "GetServiceProfile", 
            path: "/service-profiles/{Id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a service profile.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceProfile(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceProfileResponse {
        let input = GetServiceProfileRequest(
            id: id
        )
        return try await self.getServiceProfile(input, logger: logger)
    }

    /// Gets information about a wireless device.
    @Sendable
    @inlinable
    public func getWirelessDevice(_ input: GetWirelessDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessDeviceResponse {
        try await self.client.execute(
            operation: "GetWirelessDevice", 
            path: "/wireless-devices/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a wireless device.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the wireless device to get.
    ///   - identifierType: The type of identifier used in identifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessDevice(
        identifier: String,
        identifierType: WirelessDeviceIdType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessDeviceResponse {
        let input = GetWirelessDeviceRequest(
            identifier: identifier, 
            identifierType: identifierType
        )
        return try await self.getWirelessDevice(input, logger: logger)
    }

    /// Get information about an import task and count of device onboarding summary information for the import task.
    @Sendable
    @inlinable
    public func getWirelessDeviceImportTask(_ input: GetWirelessDeviceImportTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessDeviceImportTaskResponse {
        try await self.client.execute(
            operation: "GetWirelessDeviceImportTask", 
            path: "/wireless_device_import_task/{Id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get information about an import task and count of device onboarding summary information for the import task.
    ///
    /// Parameters:
    ///   - id: The identifier of the import task for which information is requested.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessDeviceImportTask(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessDeviceImportTaskResponse {
        let input = GetWirelessDeviceImportTaskRequest(
            id: id
        )
        return try await self.getWirelessDeviceImportTask(input, logger: logger)
    }

    /// Gets operating information about a wireless device.
    @Sendable
    @inlinable
    public func getWirelessDeviceStatistics(_ input: GetWirelessDeviceStatisticsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessDeviceStatisticsResponse {
        try await self.client.execute(
            operation: "GetWirelessDeviceStatistics", 
            path: "/wireless-devices/{WirelessDeviceId}/statistics", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets operating information about a wireless device.
    ///
    /// Parameters:
    ///   - wirelessDeviceId: The ID of the wireless device for which to get the data.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessDeviceStatistics(
        wirelessDeviceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessDeviceStatisticsResponse {
        let input = GetWirelessDeviceStatisticsRequest(
            wirelessDeviceId: wirelessDeviceId
        )
        return try await self.getWirelessDeviceStatistics(input, logger: logger)
    }

    /// Gets information about a wireless gateway.
    @Sendable
    @inlinable
    public func getWirelessGateway(_ input: GetWirelessGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessGatewayResponse {
        try await self.client.execute(
            operation: "GetWirelessGateway", 
            path: "/wireless-gateways/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a wireless gateway.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the wireless gateway to get.
    ///   - identifierType: The type of identifier used in identifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessGateway(
        identifier: String,
        identifierType: WirelessGatewayIdType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessGatewayResponse {
        let input = GetWirelessGatewayRequest(
            identifier: identifier, 
            identifierType: identifierType
        )
        return try await self.getWirelessGateway(input, logger: logger)
    }

    /// Gets the ID of the certificate that is currently associated with a wireless gateway.
    @Sendable
    @inlinable
    public func getWirelessGatewayCertificate(_ input: GetWirelessGatewayCertificateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessGatewayCertificateResponse {
        try await self.client.execute(
            operation: "GetWirelessGatewayCertificate", 
            path: "/wireless-gateways/{Id}/certificate", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the ID of the certificate that is currently associated with a wireless gateway.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessGatewayCertificate(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessGatewayCertificateResponse {
        let input = GetWirelessGatewayCertificateRequest(
            id: id
        )
        return try await self.getWirelessGatewayCertificate(input, logger: logger)
    }

    /// Gets the firmware version and other information about a wireless gateway.
    @Sendable
    @inlinable
    public func getWirelessGatewayFirmwareInformation(_ input: GetWirelessGatewayFirmwareInformationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessGatewayFirmwareInformationResponse {
        try await self.client.execute(
            operation: "GetWirelessGatewayFirmwareInformation", 
            path: "/wireless-gateways/{Id}/firmware-information", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the firmware version and other information about a wireless gateway.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessGatewayFirmwareInformation(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessGatewayFirmwareInformationResponse {
        let input = GetWirelessGatewayFirmwareInformationRequest(
            id: id
        )
        return try await self.getWirelessGatewayFirmwareInformation(input, logger: logger)
    }

    /// Gets operating information about a wireless gateway.
    @Sendable
    @inlinable
    public func getWirelessGatewayStatistics(_ input: GetWirelessGatewayStatisticsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessGatewayStatisticsResponse {
        try await self.client.execute(
            operation: "GetWirelessGatewayStatistics", 
            path: "/wireless-gateways/{WirelessGatewayId}/statistics", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets operating information about a wireless gateway.
    ///
    /// Parameters:
    ///   - wirelessGatewayId: The ID of the wireless gateway for which to get the data.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessGatewayStatistics(
        wirelessGatewayId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessGatewayStatisticsResponse {
        let input = GetWirelessGatewayStatisticsRequest(
            wirelessGatewayId: wirelessGatewayId
        )
        return try await self.getWirelessGatewayStatistics(input, logger: logger)
    }

    /// Gets information about a wireless gateway task.
    @Sendable
    @inlinable
    public func getWirelessGatewayTask(_ input: GetWirelessGatewayTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessGatewayTaskResponse {
        try await self.client.execute(
            operation: "GetWirelessGatewayTask", 
            path: "/wireless-gateways/{Id}/tasks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a wireless gateway task.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessGatewayTask(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessGatewayTaskResponse {
        let input = GetWirelessGatewayTaskRequest(
            id: id
        )
        return try await self.getWirelessGatewayTask(input, logger: logger)
    }

    /// Gets information about a wireless gateway task definition.
    @Sendable
    @inlinable
    public func getWirelessGatewayTaskDefinition(_ input: GetWirelessGatewayTaskDefinitionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWirelessGatewayTaskDefinitionResponse {
        try await self.client.execute(
            operation: "GetWirelessGatewayTaskDefinition", 
            path: "/wireless-gateway-task-definitions/{Id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a wireless gateway task definition.
    ///
    /// Parameters:
    ///   - id: The ID of the resource to get.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWirelessGatewayTaskDefinition(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWirelessGatewayTaskDefinitionResponse {
        let input = GetWirelessGatewayTaskDefinitionRequest(
            id: id
        )
        return try await self.getWirelessGatewayTaskDefinition(input, logger: logger)
    }

    /// Lists the destinations registered to your AWS account.
    @Sendable
    @inlinable
    public func listDestinations(_ input: ListDestinationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDestinationsResponse {
        try await self.client.execute(
            operation: "ListDestinations", 
            path: "/destinations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the destinations registered to your AWS account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDestinations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDestinationsResponse {
        let input = ListDestinationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDestinations(input, logger: logger)
    }

    /// Lists the device profiles registered to your AWS account.
    @Sendable
    @inlinable
    public func listDeviceProfiles(_ input: ListDeviceProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDeviceProfilesResponse {
        try await self.client.execute(
            operation: "ListDeviceProfiles", 
            path: "/device-profiles", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the device profiles registered to your AWS account.
    ///
    /// Parameters:
    ///   - deviceProfileType: A filter to list only device profiles that use this type, which can be LoRaWAN or Sidewalk.
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDeviceProfiles(
        deviceProfileType: DeviceProfileType? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDeviceProfilesResponse {
        let input = ListDeviceProfilesRequest(
            deviceProfileType: deviceProfileType, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDeviceProfiles(input, logger: logger)
    }

    /// List the Sidewalk devices in an import task and their onboarding status.
    @Sendable
    @inlinable
    public func listDevicesForWirelessDeviceImportTask(_ input: ListDevicesForWirelessDeviceImportTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDevicesForWirelessDeviceImportTaskResponse {
        try await self.client.execute(
            operation: "ListDevicesForWirelessDeviceImportTask", 
            path: "/wireless_device_import_task", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List the Sidewalk devices in an import task and their onboarding status.
    ///
    /// Parameters:
    ///   - id: The identifier of the import task for which wireless devices are listed.
    ///   - maxResults: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - status: The status of the devices in the import task.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDevicesForWirelessDeviceImportTask(
        id: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        status: OnboardStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDevicesForWirelessDeviceImportTaskResponse {
        let input = ListDevicesForWirelessDeviceImportTaskRequest(
            id: id, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            status: status
        )
        return try await self.listDevicesForWirelessDeviceImportTask(input, logger: logger)
    }

    /// List event configurations where at least one event topic has been enabled.
    @Sendable
    @inlinable
    public func listEventConfigurations(_ input: ListEventConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEventConfigurationsResponse {
        try await self.client.execute(
            operation: "ListEventConfigurations", 
            path: "/event-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List event configurations where at least one event topic has been enabled.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - resourceType: Resource type to filter event configurations.
    ///   - logger: Logger use during operation
    @inlinable
    public func listEventConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceType: EventNotificationResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEventConfigurationsResponse {
        let input = ListEventConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceType: resourceType
        )
        return try await self.listEventConfigurations(input, logger: logger)
    }

    /// Lists the FUOTA tasks registered to your AWS account.
    @Sendable
    @inlinable
    public func listFuotaTasks(_ input: ListFuotaTasksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFuotaTasksResponse {
        try await self.client.execute(
            operation: "ListFuotaTasks", 
            path: "/fuota-tasks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the FUOTA tasks registered to your AWS account.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFuotaTasks(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFuotaTasksResponse {
        let input = ListFuotaTasksRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFuotaTasks(input, logger: logger)
    }

    /// Lists the multicast groups registered to your AWS account.
    @Sendable
    @inlinable
    public func listMulticastGroups(_ input: ListMulticastGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMulticastGroupsResponse {
        try await self.client.execute(
            operation: "ListMulticastGroups", 
            path: "/multicast-groups", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the multicast groups registered to your AWS account.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMulticastGroups(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMulticastGroupsResponse {
        let input = ListMulticastGroupsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMulticastGroups(input, logger: logger)
    }

    /// List all multicast groups associated with a FUOTA task.
    @Sendable
    @inlinable
    public func listMulticastGroupsByFuotaTask(_ input: ListMulticastGroupsByFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMulticastGroupsByFuotaTaskResponse {
        try await self.client.execute(
            operation: "ListMulticastGroupsByFuotaTask", 
            path: "/fuota-tasks/{Id}/multicast-groups", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all multicast groups associated with a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - maxResults: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMulticastGroupsByFuotaTask(
        id: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMulticastGroupsByFuotaTaskResponse {
        let input = ListMulticastGroupsByFuotaTaskRequest(
            id: id, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listMulticastGroupsByFuotaTask(input, logger: logger)
    }

    /// Lists the network analyzer configurations.
    @Sendable
    @inlinable
    public func listNetworkAnalyzerConfigurations(_ input: ListNetworkAnalyzerConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNetworkAnalyzerConfigurationsResponse {
        try await self.client.execute(
            operation: "ListNetworkAnalyzerConfigurations", 
            path: "/network-analyzer-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the network analyzer configurations.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNetworkAnalyzerConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNetworkAnalyzerConfigurationsResponse {
        let input = ListNetworkAnalyzerConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listNetworkAnalyzerConfigurations(input, logger: logger)
    }

    /// Lists the partner accounts associated with your AWS account.
    @Sendable
    @inlinable
    public func listPartnerAccounts(_ input: ListPartnerAccountsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPartnerAccountsResponse {
        try await self.client.execute(
            operation: "ListPartnerAccounts", 
            path: "/partner-accounts", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the partner accounts associated with your AWS account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPartnerAccounts(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPartnerAccountsResponse {
        let input = ListPartnerAccountsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPartnerAccounts(input, logger: logger)
    }

    /// List position configurations for a given resource, such as positioning solvers.  This action is no longer supported. Calls to retrieve position information should use the GetResourcePosition API operation instead.
    @available(*, deprecated, message: "This operation is no longer supported.")
    @Sendable
    @inlinable
    public func listPositionConfigurations(_ input: ListPositionConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPositionConfigurationsResponse {
        try await self.client.execute(
            operation: "ListPositionConfigurations", 
            path: "/position-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List position configurations for a given resource, such as positioning solvers.  This action is no longer supported. Calls to retrieve position information should use the GetResourcePosition API operation instead.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - resourceType: Resource type for which position configurations are listed.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "This operation is no longer supported.")
    @inlinable
    public func listPositionConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceType: PositionResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPositionConfigurationsResponse {
        let input = ListPositionConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceType: resourceType
        )
        return try await self.listPositionConfigurations(input, logger: logger)
    }

    /// List queued messages in the downlink queue.
    @Sendable
    @inlinable
    public func listQueuedMessages(_ input: ListQueuedMessagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListQueuedMessagesResponse {
        try await self.client.execute(
            operation: "ListQueuedMessages", 
            path: "/wireless-devices/{Id}/data", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List queued messages in the downlink queue.
    ///
    /// Parameters:
    ///   - id: The ID of a given wireless device which the downlink message packets are being sent.
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - wirelessDeviceType: The wireless device type, whic can be either Sidewalk or LoRaWAN.
    ///   - logger: Logger use during operation
    @inlinable
    public func listQueuedMessages(
        id: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        wirelessDeviceType: WirelessDeviceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListQueuedMessagesResponse {
        let input = ListQueuedMessagesRequest(
            id: id, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            wirelessDeviceType: wirelessDeviceType
        )
        return try await self.listQueuedMessages(input, logger: logger)
    }

    /// Lists the service profiles registered to your AWS account.
    @Sendable
    @inlinable
    public func listServiceProfiles(_ input: ListServiceProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServiceProfilesResponse {
        try await self.client.execute(
            operation: "ListServiceProfiles", 
            path: "/service-profiles", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the service profiles registered to your AWS account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServiceProfiles(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServiceProfilesResponse {
        let input = ListServiceProfilesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listServiceProfiles(input, logger: logger)
    }

    /// Lists the tags (metadata) you have assigned to the resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags (metadata) you have assigned to the resource.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource for which you want to list tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// List wireless devices that have been added to an import task.
    @Sendable
    @inlinable
    public func listWirelessDeviceImportTasks(_ input: ListWirelessDeviceImportTasksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWirelessDeviceImportTasksResponse {
        try await self.client.execute(
            operation: "ListWirelessDeviceImportTasks", 
            path: "/wireless_device_import_tasks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List wireless devices that have been added to an import task.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWirelessDeviceImportTasks(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWirelessDeviceImportTasksResponse {
        let input = ListWirelessDeviceImportTasksRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listWirelessDeviceImportTasks(input, logger: logger)
    }

    /// Lists the wireless devices registered to your AWS account.
    @Sendable
    @inlinable
    public func listWirelessDevices(_ input: ListWirelessDevicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWirelessDevicesResponse {
        try await self.client.execute(
            operation: "ListWirelessDevices", 
            path: "/wireless-devices", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the wireless devices registered to your AWS account.
    ///
    /// Parameters:
    ///   - destinationName: A filter to list only the wireless devices that use this destination.
    ///   - deviceProfileId: A filter to list only the wireless devices that use this device profile.
    ///   - fuotaTaskId: 
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - multicastGroupId: 
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - serviceProfileId: A filter to list only the wireless devices that use this service profile.
    ///   - wirelessDeviceType: A filter to list only the wireless devices that use this wireless device type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWirelessDevices(
        destinationName: String? = nil,
        deviceProfileId: String? = nil,
        fuotaTaskId: String? = nil,
        maxResults: Int? = nil,
        multicastGroupId: String? = nil,
        nextToken: String? = nil,
        serviceProfileId: String? = nil,
        wirelessDeviceType: WirelessDeviceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWirelessDevicesResponse {
        let input = ListWirelessDevicesRequest(
            destinationName: destinationName, 
            deviceProfileId: deviceProfileId, 
            fuotaTaskId: fuotaTaskId, 
            maxResults: maxResults, 
            multicastGroupId: multicastGroupId, 
            nextToken: nextToken, 
            serviceProfileId: serviceProfileId, 
            wirelessDeviceType: wirelessDeviceType
        )
        return try await self.listWirelessDevices(input, logger: logger)
    }

    /// List the wireless gateway tasks definitions registered to your AWS account.
    @Sendable
    @inlinable
    public func listWirelessGatewayTaskDefinitions(_ input: ListWirelessGatewayTaskDefinitionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWirelessGatewayTaskDefinitionsResponse {
        try await self.client.execute(
            operation: "ListWirelessGatewayTaskDefinitions", 
            path: "/wireless-gateway-task-definitions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List the wireless gateway tasks definitions registered to your AWS account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - taskDefinitionType: A filter to list only the wireless gateway task definitions that use this task definition type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWirelessGatewayTaskDefinitions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        taskDefinitionType: WirelessGatewayTaskDefinitionType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWirelessGatewayTaskDefinitionsResponse {
        let input = ListWirelessGatewayTaskDefinitionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            taskDefinitionType: taskDefinitionType
        )
        return try await self.listWirelessGatewayTaskDefinitions(input, logger: logger)
    }

    /// Lists the wireless gateways registered to your AWS account.
    @Sendable
    @inlinable
    public func listWirelessGateways(_ input: ListWirelessGatewaysRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWirelessGatewaysResponse {
        try await self.client.execute(
            operation: "ListWirelessGateways", 
            path: "/wireless-gateways", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the wireless gateways registered to your AWS account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - nextToken: To retrieve the next set of results, the nextToken value from a previous response; otherwise null to receive the first set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWirelessGateways(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWirelessGatewaysResponse {
        let input = ListWirelessGatewaysRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listWirelessGateways(input, logger: logger)
    }

    /// Put position configuration for a given resource.  This action is no longer supported. Calls to update the position configuration should use the UpdateResourcePosition API operation instead.
    @available(*, deprecated, message: "This operation is no longer supported.")
    @Sendable
    @inlinable
    public func putPositionConfiguration(_ input: PutPositionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutPositionConfigurationResponse {
        try await self.client.execute(
            operation: "PutPositionConfiguration", 
            path: "/position-configurations/{ResourceIdentifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Put position configuration for a given resource.  This action is no longer supported. Calls to update the position configuration should use the UpdateResourcePosition API operation instead.
    ///
    /// Parameters:
    ///   - destination: The position data destination that describes the AWS IoT rule that processes the device's position data for use by AWS IoT Core for LoRaWAN.
    ///   - resourceIdentifier: Resource identifier used to update the position configuration.
    ///   - resourceType: Resource type of the resource for which you want to update the position configuration.
    ///   - solvers: The positioning solvers used to update the position configuration of the resource.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "This operation is no longer supported.")
    @inlinable
    public func putPositionConfiguration(
        destination: String? = nil,
        resourceIdentifier: String,
        resourceType: PositionResourceType,
        solvers: PositionSolverConfigurations? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutPositionConfigurationResponse {
        let input = PutPositionConfigurationRequest(
            destination: destination, 
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType, 
            solvers: solvers
        )
        return try await self.putPositionConfiguration(input, logger: logger)
    }

    /// Sets the log-level override for a resource ID and resource type. A limit of 200 log level override can be set per account.
    @Sendable
    @inlinable
    public func putResourceLogLevel(_ input: PutResourceLogLevelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutResourceLogLevelResponse {
        try await self.client.execute(
            operation: "PutResourceLogLevel", 
            path: "/log-levels/{ResourceIdentifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sets the log-level override for a resource ID and resource type. A limit of 200 log level override can be set per account.
    ///
    /// Parameters:
    ///   - logLevel: 
    ///   - resourceIdentifier: 
    ///   - resourceType: The type of resource, which can be WirelessDevice, WirelessGateway, or FuotaTask.
    ///   - logger: Logger use during operation
    @inlinable
    public func putResourceLogLevel(
        logLevel: LogLevel,
        resourceIdentifier: String,
        resourceType: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutResourceLogLevelResponse {
        let input = PutResourceLogLevelRequest(
            logLevel: logLevel, 
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType
        )
        return try await self.putResourceLogLevel(input, logger: logger)
    }

    /// Removes the log-level overrides for all resources; wireless devices, wireless gateways, and FUOTA tasks.
    @Sendable
    @inlinable
    public func resetAllResourceLogLevels(_ input: ResetAllResourceLogLevelsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ResetAllResourceLogLevelsResponse {
        try await self.client.execute(
            operation: "ResetAllResourceLogLevels", 
            path: "/log-levels", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the log-level overrides for all resources; wireless devices, wireless gateways, and FUOTA tasks.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func resetAllResourceLogLevels(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ResetAllResourceLogLevelsResponse {
        let input = ResetAllResourceLogLevelsRequest(
        )
        return try await self.resetAllResourceLogLevels(input, logger: logger)
    }

    /// Removes the log-level override, if any, for a specific resource ID and resource type. It can be used for a wireless device, a wireless gateway, or a FUOTA task.
    @Sendable
    @inlinable
    public func resetResourceLogLevel(_ input: ResetResourceLogLevelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ResetResourceLogLevelResponse {
        try await self.client.execute(
            operation: "ResetResourceLogLevel", 
            path: "/log-levels/{ResourceIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the log-level override, if any, for a specific resource ID and resource type. It can be used for a wireless device, a wireless gateway, or a FUOTA task.
    ///
    /// Parameters:
    ///   - resourceIdentifier: 
    ///   - resourceType: The type of resource, which can be WirelessDevice, WirelessGateway, or FuotaTask.
    ///   - logger: Logger use during operation
    @inlinable
    public func resetResourceLogLevel(
        resourceIdentifier: String,
        resourceType: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ResetResourceLogLevelResponse {
        let input = ResetResourceLogLevelRequest(
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType
        )
        return try await self.resetResourceLogLevel(input, logger: logger)
    }

    /// Sends the specified data to a multicast group.
    @Sendable
    @inlinable
    public func sendDataToMulticastGroup(_ input: SendDataToMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendDataToMulticastGroupResponse {
        try await self.client.execute(
            operation: "SendDataToMulticastGroup", 
            path: "/multicast-groups/{Id}/data", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sends the specified data to a multicast group.
    ///
    /// Parameters:
    ///   - id: 
    ///   - payloadData: 
    ///   - wirelessMetadata: 
    ///   - logger: Logger use during operation
    @inlinable
    public func sendDataToMulticastGroup(
        id: String,
        payloadData: String,
        wirelessMetadata: MulticastWirelessMetadata,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendDataToMulticastGroupResponse {
        let input = SendDataToMulticastGroupRequest(
            id: id, 
            payloadData: payloadData, 
            wirelessMetadata: wirelessMetadata
        )
        return try await self.sendDataToMulticastGroup(input, logger: logger)
    }

    /// Sends a decrypted application data frame to a device.
    @Sendable
    @inlinable
    public func sendDataToWirelessDevice(_ input: SendDataToWirelessDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendDataToWirelessDeviceResponse {
        try await self.client.execute(
            operation: "SendDataToWirelessDevice", 
            path: "/wireless-devices/{Id}/data", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sends a decrypted application data frame to a device.
    ///
    /// Parameters:
    ///   - id: The ID of the wireless device to receive the data.
    ///   - payloadData: 
    ///   - transmitMode: The transmit mode to use to send data to the wireless device. Can be: 0 for UM (unacknowledge mode) or 1 for AM (acknowledge mode).
    ///   - wirelessMetadata: Metadata about the message request.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendDataToWirelessDevice(
        id: String,
        payloadData: String,
        transmitMode: Int,
        wirelessMetadata: WirelessMetadata? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendDataToWirelessDeviceResponse {
        let input = SendDataToWirelessDeviceRequest(
            id: id, 
            payloadData: payloadData, 
            transmitMode: transmitMode, 
            wirelessMetadata: wirelessMetadata
        )
        return try await self.sendDataToWirelessDevice(input, logger: logger)
    }

    /// Starts a bulk association of all qualifying wireless devices with a multicast group.
    @Sendable
    @inlinable
    public func startBulkAssociateWirelessDeviceWithMulticastGroup(_ input: StartBulkAssociateWirelessDeviceWithMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartBulkAssociateWirelessDeviceWithMulticastGroupResponse {
        try await self.client.execute(
            operation: "StartBulkAssociateWirelessDeviceWithMulticastGroup", 
            path: "/multicast-groups/{Id}/bulk", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a bulk association of all qualifying wireless devices with a multicast group.
    ///
    /// Parameters:
    ///   - id: 
    ///   - queryString: 
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func startBulkAssociateWirelessDeviceWithMulticastGroup(
        id: String,
        queryString: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartBulkAssociateWirelessDeviceWithMulticastGroupResponse {
        let input = StartBulkAssociateWirelessDeviceWithMulticastGroupRequest(
            id: id, 
            queryString: queryString, 
            tags: tags
        )
        return try await self.startBulkAssociateWirelessDeviceWithMulticastGroup(input, logger: logger)
    }

    /// Starts a bulk disassociatin of all qualifying wireless devices from a multicast group.
    @Sendable
    @inlinable
    public func startBulkDisassociateWirelessDeviceFromMulticastGroup(_ input: StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartBulkDisassociateWirelessDeviceFromMulticastGroupResponse {
        try await self.client.execute(
            operation: "StartBulkDisassociateWirelessDeviceFromMulticastGroup", 
            path: "/multicast-groups/{Id}/bulk", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a bulk disassociatin of all qualifying wireless devices from a multicast group.
    ///
    /// Parameters:
    ///   - id: 
    ///   - queryString: 
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func startBulkDisassociateWirelessDeviceFromMulticastGroup(
        id: String,
        queryString: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartBulkDisassociateWirelessDeviceFromMulticastGroupResponse {
        let input = StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest(
            id: id, 
            queryString: queryString, 
            tags: tags
        )
        return try await self.startBulkDisassociateWirelessDeviceFromMulticastGroup(input, logger: logger)
    }

    /// Starts a FUOTA task.
    @Sendable
    @inlinable
    public func startFuotaTask(_ input: StartFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartFuotaTaskResponse {
        try await self.client.execute(
            operation: "StartFuotaTask", 
            path: "/fuota-tasks/{Id}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a FUOTA task.
    ///
    /// Parameters:
    ///   - id: 
    ///   - loRaWAN: 
    ///   - logger: Logger use during operation
    @inlinable
    public func startFuotaTask(
        id: String,
        loRaWAN: LoRaWANStartFuotaTask? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartFuotaTaskResponse {
        let input = StartFuotaTaskRequest(
            id: id, 
            loRaWAN: loRaWAN
        )
        return try await self.startFuotaTask(input, logger: logger)
    }

    /// Starts a multicast group session.
    @Sendable
    @inlinable
    public func startMulticastGroupSession(_ input: StartMulticastGroupSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartMulticastGroupSessionResponse {
        try await self.client.execute(
            operation: "StartMulticastGroupSession", 
            path: "/multicast-groups/{Id}/session", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a multicast group session.
    ///
    /// Parameters:
    ///   - id: 
    ///   - loRaWAN: 
    ///   - logger: Logger use during operation
    @inlinable
    public func startMulticastGroupSession(
        id: String,
        loRaWAN: LoRaWANMulticastSession,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartMulticastGroupSessionResponse {
        let input = StartMulticastGroupSessionRequest(
            id: id, 
            loRaWAN: loRaWAN
        )
        return try await self.startMulticastGroupSession(input, logger: logger)
    }

    /// Start import task for a single wireless device.
    @Sendable
    @inlinable
    public func startSingleWirelessDeviceImportTask(_ input: StartSingleWirelessDeviceImportTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartSingleWirelessDeviceImportTaskResponse {
        try await self.client.execute(
            operation: "StartSingleWirelessDeviceImportTask", 
            path: "/wireless_single_device_import_task", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Start import task for a single wireless device.
    ///
    /// Parameters:
    ///   - clientRequestToken: 
    ///   - destinationName: The name of the Sidewalk destination that describes the IoT rule to route messages from the device in the import task that will be onboarded to AWS IoT Wireless.
    ///   - deviceName: The name of the wireless device for which an import task is being started.
    ///   - sidewalk: The Sidewalk-related parameters for importing a single wireless device.
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func startSingleWirelessDeviceImportTask(
        clientRequestToken: String? = StartSingleWirelessDeviceImportTaskRequest.idempotencyToken(),
        destinationName: String,
        deviceName: String? = nil,
        sidewalk: SidewalkSingleStartImportInfo,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartSingleWirelessDeviceImportTaskResponse {
        let input = StartSingleWirelessDeviceImportTaskRequest(
            clientRequestToken: clientRequestToken, 
            destinationName: destinationName, 
            deviceName: deviceName, 
            sidewalk: sidewalk, 
            tags: tags
        )
        return try await self.startSingleWirelessDeviceImportTask(input, logger: logger)
    }

    /// Start import task for provisioning Sidewalk devices in bulk using an S3 CSV file.
    @Sendable
    @inlinable
    public func startWirelessDeviceImportTask(_ input: StartWirelessDeviceImportTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartWirelessDeviceImportTaskResponse {
        try await self.client.execute(
            operation: "StartWirelessDeviceImportTask", 
            path: "/wireless_device_import_task", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Start import task for provisioning Sidewalk devices in bulk using an S3 CSV file.
    ///
    /// Parameters:
    ///   - clientRequestToken: 
    ///   - destinationName: The name of the Sidewalk destination that describes the IoT rule to route messages from the devices in the import task that are onboarded to AWS IoT Wireless.
    ///   - sidewalk: The Sidewalk-related parameters for importing wireless devices that need to be provisioned in bulk.
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func startWirelessDeviceImportTask(
        clientRequestToken: String? = StartWirelessDeviceImportTaskRequest.idempotencyToken(),
        destinationName: String,
        sidewalk: SidewalkStartImportInfo,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartWirelessDeviceImportTaskResponse {
        let input = StartWirelessDeviceImportTaskRequest(
            clientRequestToken: clientRequestToken, 
            destinationName: destinationName, 
            sidewalk: sidewalk, 
            tags: tags
        )
        return try await self.startWirelessDeviceImportTask(input, logger: logger)
    }

    /// Adds a tag to a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds a tag to a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource to add tags to.
    ///   - tags: Adds to or modifies the tags of the given resource. Tags are metadata that you can use to manage a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Simulates a provisioned device by sending an uplink data payload of Hello.
    @Sendable
    @inlinable
    public func testWirelessDevice(_ input: TestWirelessDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TestWirelessDeviceResponse {
        try await self.client.execute(
            operation: "TestWirelessDevice", 
            path: "/wireless-devices/{Id}/test", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Simulates a provisioned device by sending an uplink data payload of Hello.
    ///
    /// Parameters:
    ///   - id: The ID of the wireless device to test.
    ///   - logger: Logger use during operation
    @inlinable
    public func testWirelessDevice(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TestWirelessDeviceResponse {
        let input = TestWirelessDeviceRequest(
            id: id
        )
        return try await self.testWirelessDevice(input, logger: logger)
    }

    /// Removes one or more tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes one or more tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource to remove tags from.
    ///   - tagKeys: A list of the keys of the tags to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates properties of a destination.
    @Sendable
    @inlinable
    public func updateDestination(_ input: UpdateDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDestinationResponse {
        try await self.client.execute(
            operation: "UpdateDestination", 
            path: "/destinations/{Name}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates properties of a destination.
    ///
    /// Parameters:
    ///   - description: A new description of the resource.
    ///   - expression: The new rule name or topic rule to send messages to.
    ///   - expressionType: The type of value in Expression.
    ///   - name: The new name of the resource.
    ///   - roleArn: The ARN of the IAM Role that authorizes the destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDestination(
        description: String? = nil,
        expression: String? = nil,
        expressionType: ExpressionType? = nil,
        name: String,
        roleArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDestinationResponse {
        let input = UpdateDestinationRequest(
            description: description, 
            expression: expression, 
            expressionType: expressionType, 
            name: name, 
            roleArn: roleArn
        )
        return try await self.updateDestination(input, logger: logger)
    }

    /// Update the event configuration based on resource types.
    @Sendable
    @inlinable
    public func updateEventConfigurationByResourceTypes(_ input: UpdateEventConfigurationByResourceTypesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEventConfigurationByResourceTypesResponse {
        try await self.client.execute(
            operation: "UpdateEventConfigurationByResourceTypes", 
            path: "/event-configurations-resource-types", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the event configuration based on resource types.
    ///
    /// Parameters:
    ///   - connectionStatus: Connection status resource type event configuration object for enabling and disabling wireless gateway topic.
    ///   - deviceRegistrationState: Device registration state resource type event configuration object for enabling and disabling wireless gateway topic.
    ///   - join: Join resource type event configuration object for enabling and disabling wireless device topic.
    ///   - messageDeliveryStatus: Message delivery status resource type event configuration object for enabling and disabling wireless device topic.
    ///   - proximity: Proximity resource type event configuration object for enabling and disabling wireless gateway topic.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEventConfigurationByResourceTypes(
        connectionStatus: ConnectionStatusResourceTypeEventConfiguration? = nil,
        deviceRegistrationState: DeviceRegistrationStateResourceTypeEventConfiguration? = nil,
        join: JoinResourceTypeEventConfiguration? = nil,
        messageDeliveryStatus: MessageDeliveryStatusResourceTypeEventConfiguration? = nil,
        proximity: ProximityResourceTypeEventConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEventConfigurationByResourceTypesResponse {
        let input = UpdateEventConfigurationByResourceTypesRequest(
            connectionStatus: connectionStatus, 
            deviceRegistrationState: deviceRegistrationState, 
            join: join, 
            messageDeliveryStatus: messageDeliveryStatus, 
            proximity: proximity
        )
        return try await self.updateEventConfigurationByResourceTypes(input, logger: logger)
    }

    /// Updates properties of a FUOTA task.
    @Sendable
    @inlinable
    public func updateFuotaTask(_ input: UpdateFuotaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFuotaTaskResponse {
        try await self.client.execute(
            operation: "UpdateFuotaTask", 
            path: "/fuota-tasks/{Id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates properties of a FUOTA task.
    ///
    /// Parameters:
    ///   - description: 
    ///   - descriptor: 
    ///   - firmwareUpdateImage: 
    ///   - firmwareUpdateRole: 
    ///   - fragmentIntervalMS: 
    ///   - fragmentSizeBytes: 
    ///   - id: 
    ///   - loRaWAN: 
    ///   - name: 
    ///   - redundancyPercent: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFuotaTask(
        description: String? = nil,
        descriptor: String? = nil,
        firmwareUpdateImage: String? = nil,
        firmwareUpdateRole: String? = nil,
        fragmentIntervalMS: Int? = nil,
        fragmentSizeBytes: Int? = nil,
        id: String,
        loRaWAN: LoRaWANFuotaTask? = nil,
        name: String? = nil,
        redundancyPercent: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFuotaTaskResponse {
        let input = UpdateFuotaTaskRequest(
            description: description, 
            descriptor: descriptor, 
            firmwareUpdateImage: firmwareUpdateImage, 
            firmwareUpdateRole: firmwareUpdateRole, 
            fragmentIntervalMS: fragmentIntervalMS, 
            fragmentSizeBytes: fragmentSizeBytes, 
            id: id, 
            loRaWAN: loRaWAN, 
            name: name, 
            redundancyPercent: redundancyPercent
        )
        return try await self.updateFuotaTask(input, logger: logger)
    }

    /// Set default log level, or log levels by resource types. This can be for wireless device, wireless gateway, or FUOTA task log options, and is used to control the log messages that'll be displayed in CloudWatch.
    @Sendable
    @inlinable
    public func updateLogLevelsByResourceTypes(_ input: UpdateLogLevelsByResourceTypesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateLogLevelsByResourceTypesResponse {
        try await self.client.execute(
            operation: "UpdateLogLevelsByResourceTypes", 
            path: "/log-levels", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Set default log level, or log levels by resource types. This can be for wireless device, wireless gateway, or FUOTA task log options, and is used to control the log messages that'll be displayed in CloudWatch.
    ///
    /// Parameters:
    ///   - defaultLogLevel: 
    ///   - fuotaTaskLogOptions: 
    ///   - wirelessDeviceLogOptions: 
    ///   - wirelessGatewayLogOptions: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateLogLevelsByResourceTypes(
        defaultLogLevel: LogLevel? = nil,
        fuotaTaskLogOptions: [FuotaTaskLogOption]? = nil,
        wirelessDeviceLogOptions: [WirelessDeviceLogOption]? = nil,
        wirelessGatewayLogOptions: [WirelessGatewayLogOption]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateLogLevelsByResourceTypesResponse {
        let input = UpdateLogLevelsByResourceTypesRequest(
            defaultLogLevel: defaultLogLevel, 
            fuotaTaskLogOptions: fuotaTaskLogOptions, 
            wirelessDeviceLogOptions: wirelessDeviceLogOptions, 
            wirelessGatewayLogOptions: wirelessGatewayLogOptions
        )
        return try await self.updateLogLevelsByResourceTypes(input, logger: logger)
    }

    /// Update the summary metric configuration.
    @Sendable
    @inlinable
    public func updateMetricConfiguration(_ input: UpdateMetricConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMetricConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateMetricConfiguration", 
            path: "/metric-configuration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the summary metric configuration.
    ///
    /// Parameters:
    ///   - summaryMetric: The value to be used to set summary metric configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMetricConfiguration(
        summaryMetric: SummaryMetricConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMetricConfigurationResponse {
        let input = UpdateMetricConfigurationRequest(
            summaryMetric: summaryMetric
        )
        return try await self.updateMetricConfiguration(input, logger: logger)
    }

    /// Updates properties of a multicast group session.
    @Sendable
    @inlinable
    public func updateMulticastGroup(_ input: UpdateMulticastGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMulticastGroupResponse {
        try await self.client.execute(
            operation: "UpdateMulticastGroup", 
            path: "/multicast-groups/{Id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates properties of a multicast group session.
    ///
    /// Parameters:
    ///   - description: 
    ///   - id: 
    ///   - loRaWAN: 
    ///   - name: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMulticastGroup(
        description: String? = nil,
        id: String,
        loRaWAN: LoRaWANMulticast? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMulticastGroupResponse {
        let input = UpdateMulticastGroupRequest(
            description: description, 
            id: id, 
            loRaWAN: loRaWAN, 
            name: name
        )
        return try await self.updateMulticastGroup(input, logger: logger)
    }

    /// Update network analyzer configuration.
    @Sendable
    @inlinable
    public func updateNetworkAnalyzerConfiguration(_ input: UpdateNetworkAnalyzerConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNetworkAnalyzerConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateNetworkAnalyzerConfiguration", 
            path: "/network-analyzer-configurations/{ConfigurationName}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update network analyzer configuration.
    ///
    /// Parameters:
    ///   - configurationName: 
    ///   - description: 
    ///   - multicastGroupsToAdd: Multicast group resources to add to the network analyzer configuration. Provide the MulticastGroupId of the resource to add in the input array.
    ///   - multicastGroupsToRemove: Multicast group resources to remove from the network analyzer configuration. Provide the MulticastGroupId of the resources to remove in the input array.
    ///   - traceContent: 
    ///   - wirelessDevicesToAdd: Wireless device resources to add to the network analyzer configuration. Provide the WirelessDeviceId of the resource to add in the input array.
    ///   - wirelessDevicesToRemove: Wireless device resources to remove from the network analyzer configuration. Provide the WirelessDeviceId of the resources to remove in the input array.
    ///   - wirelessGatewaysToAdd: Wireless gateway resources to add to the network analyzer configuration. Provide the WirelessGatewayId of the resource to add in the input array.
    ///   - wirelessGatewaysToRemove: Wireless gateway resources to remove from the network analyzer configuration. Provide the WirelessGatewayId of the resources to remove in the input array.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNetworkAnalyzerConfiguration(
        configurationName: String,
        description: String? = nil,
        multicastGroupsToAdd: [String]? = nil,
        multicastGroupsToRemove: [String]? = nil,
        traceContent: TraceContent? = nil,
        wirelessDevicesToAdd: [String]? = nil,
        wirelessDevicesToRemove: [String]? = nil,
        wirelessGatewaysToAdd: [String]? = nil,
        wirelessGatewaysToRemove: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNetworkAnalyzerConfigurationResponse {
        let input = UpdateNetworkAnalyzerConfigurationRequest(
            configurationName: configurationName, 
            description: description, 
            multicastGroupsToAdd: multicastGroupsToAdd, 
            multicastGroupsToRemove: multicastGroupsToRemove, 
            traceContent: traceContent, 
            wirelessDevicesToAdd: wirelessDevicesToAdd, 
            wirelessDevicesToRemove: wirelessDevicesToRemove, 
            wirelessGatewaysToAdd: wirelessGatewaysToAdd, 
            wirelessGatewaysToRemove: wirelessGatewaysToRemove
        )
        return try await self.updateNetworkAnalyzerConfiguration(input, logger: logger)
    }

    /// Updates properties of a partner account.
    @Sendable
    @inlinable
    public func updatePartnerAccount(_ input: UpdatePartnerAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePartnerAccountResponse {
        try await self.client.execute(
            operation: "UpdatePartnerAccount", 
            path: "/partner-accounts/{PartnerAccountId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates properties of a partner account.
    ///
    /// Parameters:
    ///   - partnerAccountId: The ID of the partner account to update.
    ///   - partnerType: The partner type.
    ///   - sidewalk: The Sidewalk account credentials.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePartnerAccount(
        partnerAccountId: String,
        partnerType: PartnerType,
        sidewalk: SidewalkUpdateAccount,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePartnerAccountResponse {
        let input = UpdatePartnerAccountRequest(
            partnerAccountId: partnerAccountId, 
            partnerType: partnerType, 
            sidewalk: sidewalk
        )
        return try await self.updatePartnerAccount(input, logger: logger)
    }

    /// Update the position information of a resource.  This action is no longer supported. Calls to update the position information should use the UpdateResourcePosition API operation instead.
    @available(*, deprecated, message: "This operation is no longer supported.")
    @Sendable
    @inlinable
    public func updatePosition(_ input: UpdatePositionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePositionResponse {
        try await self.client.execute(
            operation: "UpdatePosition", 
            path: "/positions/{ResourceIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the position information of a resource.  This action is no longer supported. Calls to update the position information should use the UpdateResourcePosition API operation instead.
    ///
    /// Parameters:
    ///   - position: The position information of the resource.
    ///   - resourceIdentifier: Resource identifier of the resource for which position is updated.
    ///   - resourceType: Resource type of the resource for which position is updated.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "This operation is no longer supported.")
    @inlinable
    public func updatePosition(
        position: [Float],
        resourceIdentifier: String,
        resourceType: PositionResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePositionResponse {
        let input = UpdatePositionRequest(
            position: position, 
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType
        )
        return try await self.updatePosition(input, logger: logger)
    }

    /// Update the event configuration for a particular resource identifier.
    @Sendable
    @inlinable
    public func updateResourceEventConfiguration(_ input: UpdateResourceEventConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateResourceEventConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateResourceEventConfiguration", 
            path: "/event-configurations/{Identifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the event configuration for a particular resource identifier.
    ///
    /// Parameters:
    ///   - connectionStatus: Event configuration for the connection status event.
    ///   - deviceRegistrationState: Event configuration for the device registration state event.
    ///   - identifier: Resource identifier to opt in for event messaging.
    ///   - identifierType: Identifier type of the particular resource identifier for event configuration.
    ///   - join: Event configuration for the join event.
    ///   - messageDeliveryStatus: Event configuration for the message delivery status event.
    ///   - partnerType: Partner type of the resource if the identifier type is PartnerAccountId
    ///   - proximity: Event configuration for the proximity event.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateResourceEventConfiguration(
        connectionStatus: ConnectionStatusEventConfiguration? = nil,
        deviceRegistrationState: DeviceRegistrationStateEventConfiguration? = nil,
        identifier: String,
        identifierType: IdentifierType,
        join: JoinEventConfiguration? = nil,
        messageDeliveryStatus: MessageDeliveryStatusEventConfiguration? = nil,
        partnerType: EventNotificationPartnerType? = nil,
        proximity: ProximityEventConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateResourceEventConfigurationResponse {
        let input = UpdateResourceEventConfigurationRequest(
            connectionStatus: connectionStatus, 
            deviceRegistrationState: deviceRegistrationState, 
            identifier: identifier, 
            identifierType: identifierType, 
            join: join, 
            messageDeliveryStatus: messageDeliveryStatus, 
            partnerType: partnerType, 
            proximity: proximity
        )
        return try await self.updateResourceEventConfiguration(input, logger: logger)
    }

    /// Update the position information of a given wireless device or a wireless gateway resource. The position coordinates are based on the  World Geodetic System (WGS84).
    @Sendable
    @inlinable
    public func updateResourcePosition(_ input: UpdateResourcePositionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateResourcePositionResponse {
        try await self.client.execute(
            operation: "UpdateResourcePosition", 
            path: "/resource-positions/{ResourceIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the position information of a given wireless device or a wireless gateway resource. The position coordinates are based on the  World Geodetic System (WGS84).
    ///
    /// Parameters:
    ///   - geoJsonPayload: The position information of the resource, displayed as a JSON payload. The payload uses the GeoJSON format, which a format that's used to encode geographic data structures. For more information, see GeoJSON.
    ///   - resourceIdentifier: The identifier of the resource for which position information is updated. It can be the wireless device ID or the wireless gateway ID, depending on the resource type.
    ///   - resourceType: The type of resource for which position information is updated, which can be a wireless device or a wireless gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateResourcePosition(
        geoJsonPayload: AWSHTTPBody? = nil,
        resourceIdentifier: String,
        resourceType: PositionResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateResourcePositionResponse {
        let input = UpdateResourcePositionRequest(
            geoJsonPayload: geoJsonPayload, 
            resourceIdentifier: resourceIdentifier, 
            resourceType: resourceType
        )
        return try await self.updateResourcePosition(input, logger: logger)
    }

    /// Updates properties of a wireless device.
    @Sendable
    @inlinable
    public func updateWirelessDevice(_ input: UpdateWirelessDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateWirelessDeviceResponse {
        try await self.client.execute(
            operation: "UpdateWirelessDevice", 
            path: "/wireless-devices/{Id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates properties of a wireless device.
    ///
    /// Parameters:
    ///   - description: A new description of the resource.
    ///   - destinationName: The name of the new destination for the device.
    ///   - id: The ID of the resource to update.
    ///   - loRaWAN: The updated wireless device's configuration.
    ///   - name: The new name of the resource.  The following special characters aren't accepted: <>^#~$
    ///   - positioning: FPort values for the GNSS, stream, and ClockSync functions of the positioning information.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWirelessDevice(
        description: String? = nil,
        destinationName: String? = nil,
        id: String,
        loRaWAN: LoRaWANUpdateDevice? = nil,
        name: String? = nil,
        positioning: PositioningConfigStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateWirelessDeviceResponse {
        let input = UpdateWirelessDeviceRequest(
            description: description, 
            destinationName: destinationName, 
            id: id, 
            loRaWAN: loRaWAN, 
            name: name, 
            positioning: positioning
        )
        return try await self.updateWirelessDevice(input, logger: logger)
    }

    /// Update an import task to add more devices to the task.
    @Sendable
    @inlinable
    public func updateWirelessDeviceImportTask(_ input: UpdateWirelessDeviceImportTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateWirelessDeviceImportTaskResponse {
        try await self.client.execute(
            operation: "UpdateWirelessDeviceImportTask", 
            path: "/wireless_device_import_task/{Id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update an import task to add more devices to the task.
    ///
    /// Parameters:
    ///   - id: The identifier of the import task to be updated.
    ///   - sidewalk: The Sidewalk-related parameters of the import task to be updated.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWirelessDeviceImportTask(
        id: String,
        sidewalk: SidewalkUpdateImportInfo,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateWirelessDeviceImportTaskResponse {
        let input = UpdateWirelessDeviceImportTaskRequest(
            id: id, 
            sidewalk: sidewalk
        )
        return try await self.updateWirelessDeviceImportTask(input, logger: logger)
    }

    /// Updates properties of a wireless gateway.
    @Sendable
    @inlinable
    public func updateWirelessGateway(_ input: UpdateWirelessGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateWirelessGatewayResponse {
        try await self.client.execute(
            operation: "UpdateWirelessGateway", 
            path: "/wireless-gateways/{Id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates properties of a wireless gateway.
    ///
    /// Parameters:
    ///   - description: A new description of the resource.
    ///   - id: The ID of the resource to update.
    ///   - joinEuiFilters: 
    ///   - maxEirp: The MaxEIRP value.
    ///   - name: The new name of the resource.  The following special characters aren't accepted: <>^#~$
    ///   - netIdFilters: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWirelessGateway(
        description: String? = nil,
        id: String,
        joinEuiFilters: [[String]]? = nil,
        maxEirp: Float? = nil,
        name: String? = nil,
        netIdFilters: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateWirelessGatewayResponse {
        let input = UpdateWirelessGatewayRequest(
            description: description, 
            id: id, 
            joinEuiFilters: joinEuiFilters, 
            maxEirp: maxEirp, 
            name: name, 
            netIdFilters: netIdFilters
        )
        return try await self.updateWirelessGateway(input, logger: logger)
    }
}

extension IoTWireless {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: IoTWireless, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension IoTWireless {
    /// Return PaginatorSequence for operation ``listDestinations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDestinationsPaginator(
        _ input: ListDestinationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDestinationsRequest, ListDestinationsResponse> {
        return .init(
            input: input,
            command: self.listDestinations,
            inputKey: \ListDestinationsRequest.nextToken,
            outputKey: \ListDestinationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDestinations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDestinationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDestinationsRequest, ListDestinationsResponse> {
        let input = ListDestinationsRequest(
            maxResults: maxResults
        )
        return self.listDestinationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDeviceProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDeviceProfilesPaginator(
        _ input: ListDeviceProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDeviceProfilesRequest, ListDeviceProfilesResponse> {
        return .init(
            input: input,
            command: self.listDeviceProfiles,
            inputKey: \ListDeviceProfilesRequest.nextToken,
            outputKey: \ListDeviceProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDeviceProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - deviceProfileType: A filter to list only device profiles that use this type, which can be LoRaWAN or Sidewalk.
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDeviceProfilesPaginator(
        deviceProfileType: DeviceProfileType? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDeviceProfilesRequest, ListDeviceProfilesResponse> {
        let input = ListDeviceProfilesRequest(
            deviceProfileType: deviceProfileType, 
            maxResults: maxResults
        )
        return self.listDeviceProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFuotaTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFuotaTasksPaginator(
        _ input: ListFuotaTasksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFuotaTasksRequest, ListFuotaTasksResponse> {
        return .init(
            input: input,
            command: self.listFuotaTasks,
            inputKey: \ListFuotaTasksRequest.nextToken,
            outputKey: \ListFuotaTasksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFuotaTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: 
    ///   - logger: Logger used for logging
    @inlinable
    public func listFuotaTasksPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFuotaTasksRequest, ListFuotaTasksResponse> {
        let input = ListFuotaTasksRequest(
            maxResults: maxResults
        )
        return self.listFuotaTasksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMulticastGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMulticastGroupsPaginator(
        _ input: ListMulticastGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMulticastGroupsRequest, ListMulticastGroupsResponse> {
        return .init(
            input: input,
            command: self.listMulticastGroups,
            inputKey: \ListMulticastGroupsRequest.nextToken,
            outputKey: \ListMulticastGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMulticastGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: 
    ///   - logger: Logger used for logging
    @inlinable
    public func listMulticastGroupsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMulticastGroupsRequest, ListMulticastGroupsResponse> {
        let input = ListMulticastGroupsRequest(
            maxResults: maxResults
        )
        return self.listMulticastGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMulticastGroupsByFuotaTask(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMulticastGroupsByFuotaTaskPaginator(
        _ input: ListMulticastGroupsByFuotaTaskRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMulticastGroupsByFuotaTaskRequest, ListMulticastGroupsByFuotaTaskResponse> {
        return .init(
            input: input,
            command: self.listMulticastGroupsByFuotaTask,
            inputKey: \ListMulticastGroupsByFuotaTaskRequest.nextToken,
            outputKey: \ListMulticastGroupsByFuotaTaskResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMulticastGroupsByFuotaTask(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: 
    ///   - maxResults: 
    ///   - logger: Logger used for logging
    @inlinable
    public func listMulticastGroupsByFuotaTaskPaginator(
        id: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMulticastGroupsByFuotaTaskRequest, ListMulticastGroupsByFuotaTaskResponse> {
        let input = ListMulticastGroupsByFuotaTaskRequest(
            id: id, 
            maxResults: maxResults
        )
        return self.listMulticastGroupsByFuotaTaskPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNetworkAnalyzerConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworkAnalyzerConfigurationsPaginator(
        _ input: ListNetworkAnalyzerConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNetworkAnalyzerConfigurationsRequest, ListNetworkAnalyzerConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listNetworkAnalyzerConfigurations,
            inputKey: \ListNetworkAnalyzerConfigurationsRequest.nextToken,
            outputKey: \ListNetworkAnalyzerConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNetworkAnalyzerConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: 
    ///   - logger: Logger used for logging
    @inlinable
    public func listNetworkAnalyzerConfigurationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNetworkAnalyzerConfigurationsRequest, ListNetworkAnalyzerConfigurationsResponse> {
        let input = ListNetworkAnalyzerConfigurationsRequest(
            maxResults: maxResults
        )
        return self.listNetworkAnalyzerConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPositionConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "This operation is no longer supported.")
    @inlinable
    public func listPositionConfigurationsPaginator(
        _ input: ListPositionConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPositionConfigurationsRequest, ListPositionConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listPositionConfigurations,
            inputKey: \ListPositionConfigurationsRequest.nextToken,
            outputKey: \ListPositionConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPositionConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: 
    ///   - resourceType: Resource type for which position configurations are listed.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "This operation is no longer supported.")
    @inlinable
    public func listPositionConfigurationsPaginator(
        maxResults: Int? = nil,
        resourceType: PositionResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPositionConfigurationsRequest, ListPositionConfigurationsResponse> {
        let input = ListPositionConfigurationsRequest(
            maxResults: maxResults, 
            resourceType: resourceType
        )
        return self.listPositionConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listQueuedMessages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listQueuedMessagesPaginator(
        _ input: ListQueuedMessagesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListQueuedMessagesRequest, ListQueuedMessagesResponse> {
        return .init(
            input: input,
            command: self.listQueuedMessages,
            inputKey: \ListQueuedMessagesRequest.nextToken,
            outputKey: \ListQueuedMessagesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listQueuedMessages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The ID of a given wireless device which the downlink message packets are being sent.
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - wirelessDeviceType: The wireless device type, whic can be either Sidewalk or LoRaWAN.
    ///   - logger: Logger used for logging
    @inlinable
    public func listQueuedMessagesPaginator(
        id: String,
        maxResults: Int? = nil,
        wirelessDeviceType: WirelessDeviceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListQueuedMessagesRequest, ListQueuedMessagesResponse> {
        let input = ListQueuedMessagesRequest(
            id: id, 
            maxResults: maxResults, 
            wirelessDeviceType: wirelessDeviceType
        )
        return self.listQueuedMessagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServiceProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceProfilesPaginator(
        _ input: ListServiceProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServiceProfilesRequest, ListServiceProfilesResponse> {
        return .init(
            input: input,
            command: self.listServiceProfiles,
            inputKey: \ListServiceProfilesRequest.nextToken,
            outputKey: \ListServiceProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServiceProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceProfilesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServiceProfilesRequest, ListServiceProfilesResponse> {
        let input = ListServiceProfilesRequest(
            maxResults: maxResults
        )
        return self.listServiceProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWirelessDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWirelessDevicesPaginator(
        _ input: ListWirelessDevicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWirelessDevicesRequest, ListWirelessDevicesResponse> {
        return .init(
            input: input,
            command: self.listWirelessDevices,
            inputKey: \ListWirelessDevicesRequest.nextToken,
            outputKey: \ListWirelessDevicesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWirelessDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - destinationName: A filter to list only the wireless devices that use this destination.
    ///   - deviceProfileId: A filter to list only the wireless devices that use this device profile.
    ///   - fuotaTaskId: 
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - multicastGroupId: 
    ///   - serviceProfileId: A filter to list only the wireless devices that use this service profile.
    ///   - wirelessDeviceType: A filter to list only the wireless devices that use this wireless device type.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWirelessDevicesPaginator(
        destinationName: String? = nil,
        deviceProfileId: String? = nil,
        fuotaTaskId: String? = nil,
        maxResults: Int? = nil,
        multicastGroupId: String? = nil,
        serviceProfileId: String? = nil,
        wirelessDeviceType: WirelessDeviceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWirelessDevicesRequest, ListWirelessDevicesResponse> {
        let input = ListWirelessDevicesRequest(
            destinationName: destinationName, 
            deviceProfileId: deviceProfileId, 
            fuotaTaskId: fuotaTaskId, 
            maxResults: maxResults, 
            multicastGroupId: multicastGroupId, 
            serviceProfileId: serviceProfileId, 
            wirelessDeviceType: wirelessDeviceType
        )
        return self.listWirelessDevicesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWirelessGateways(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWirelessGatewaysPaginator(
        _ input: ListWirelessGatewaysRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWirelessGatewaysRequest, ListWirelessGatewaysResponse> {
        return .init(
            input: input,
            command: self.listWirelessGateways,
            inputKey: \ListWirelessGatewaysRequest.nextToken,
            outputKey: \ListWirelessGatewaysResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWirelessGateways(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in this operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWirelessGatewaysPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWirelessGatewaysRequest, ListWirelessGatewaysResponse> {
        let input = ListWirelessGatewaysRequest(
            maxResults: maxResults
        )
        return self.listWirelessGatewaysPaginator(input, logger: logger)
    }
}

extension IoTWireless.ListDestinationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListDestinationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTWireless.ListDeviceProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListDeviceProfilesRequest {
        return .init(
            deviceProfileType: self.deviceProfileType,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTWireless.ListFuotaTasksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListFuotaTasksRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTWireless.ListMulticastGroupsByFuotaTaskRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListMulticastGroupsByFuotaTaskRequest {
        return .init(
            id: self.id,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTWireless.ListMulticastGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListMulticastGroupsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTWireless.ListNetworkAnalyzerConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListNetworkAnalyzerConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTWireless.ListPositionConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListPositionConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceType: self.resourceType
        )
    }
}

extension IoTWireless.ListQueuedMessagesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListQueuedMessagesRequest {
        return .init(
            id: self.id,
            maxResults: self.maxResults,
            nextToken: token,
            wirelessDeviceType: self.wirelessDeviceType
        )
    }
}

extension IoTWireless.ListServiceProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListServiceProfilesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTWireless.ListWirelessDevicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListWirelessDevicesRequest {
        return .init(
            destinationName: self.destinationName,
            deviceProfileId: self.deviceProfileId,
            fuotaTaskId: self.fuotaTaskId,
            maxResults: self.maxResults,
            multicastGroupId: self.multicastGroupId,
            nextToken: token,
            serviceProfileId: self.serviceProfileId,
            wirelessDeviceType: self.wirelessDeviceType
        )
    }
}

extension IoTWireless.ListWirelessGatewaysRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTWireless.ListWirelessGatewaysRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
